# learnedvector/a-hackers-ai-voice-assistant architecture

> Architecture diagram of the GitHub repository learnedvector/a-hackers-ai-voice-assistant, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-03-30). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/learnedvector/a-hackers-ai-voice-assistant
- Repository: https://github.com/learnedvector/a-hackers-ai-voice-assistant

## Overview

This repository is a collection of separate ML subsystems for a voice assistant, plus some shared orchestration glue. It is not a single monolithic application; most of the code is organized around building, training, optimizing, and demoing three core audio models:

- wake word detection
- speech recognition
- natural language understanding

There is also a placeholder package for speech synthesis, and a top-level `core.py` that appears intended to integrate the subsystems into a full assistant, though the README says that end-to-end assistant logic is still a TODO.

#### High-level architecture

The repo is organized into four main functional boundaries:

1. **Wake word subsystem**  
   Detects when the assistant should start listening.

2. **Speech recognition subsystem**  
   Converts spoken audio into text.

3. **NLU subsystem**  
   Classifies or interprets text into intents / labels.

4. **Speech synthesis subsystem**  
   Present as a package boundary, but not implemented in the file tree shown.

A fifth boundary cuts across all of them:

5. **Training / data / model optimization toolchain**  
   Each subsystem has its own dataset code, training script, and graph optimization step so models can move from research training to inference/demo usage.

#### Top-level repo layout

- `VoiceAssistant/core.py`  
  Likely the central integration point for the assistant pipeline. Based on the README, this is intended to connect wake word → speech recognition → NLU → synthesis → skills.

- `VoiceAssistant/wakeword/`  
  Wake-word detection implementation and training utilities.

- `VoiceAssistant/speechrecognition/`  
  Speech-to-text implementation, including a browser/web demo.

- `VoiceAssistant/nlu/`  
  Natural language understanding implementation and datasets.

- `VoiceAssistant/speechsynthesis/`  
  Package exists, but there are no model or engine files visible here yet.

- `fun/arnold_audio/`  
  Sample audio files used for experimentation/demo content, not part of the assistant pipeline.

- `Dockerfile`, `cpu.Dockerfile`  
  Container definitions for GPU/CUDA and CPU-only environments.

- `requirements.txt`, `rpi-requirements.txt`  
  Python dependency sets for general and Raspberry Pi-related environments.

#### Wake word subsystem

Path: `VoiceAssistant/wakeword/`

##### Purpose
This subsystem detects a trigger phrase so the assistant knows when to begin processing audio.

##### Main components
- `engine.py`  
  Inference/demo entry point for wake word detection.

- `neuralnet/`
  - `dataset.py` — dataset loading and preprocessing
  - `model.py` — network definition
  - `train.py` — model training
  - `optimize_graph.py` — exports an inference-ready optimized model
  - `__init__.py` — package boundary

- `scripts/`
  - `collect_wakeword_audio.py` — audio capture for wake word and background noise
  - `create_wakeword_jsons.py` — converts audio files into training/test manifests
  - `split_audio_into_chunks.py` — chops recordings into fixed-length segments
  - `split_commonvoice.py` — prepares Common Voice audio into chunks
  - `replicate_audios.py` — duplicates wake word samples to address class imbalance

##### Data flow
The wake word workflow is:
1. collect or prepare labeled audio,
2. create JSON manifests,
3. train the neural net,
4. optimize/export the graph,
5. run inference in `engine.py`.

##### Architectural notes
This subsystem is a self-contained binary classification pipeline:
- label `1` = wake word
- label `0` = non-wake/background speech

It relies heavily on pre-segmented audio clips and dataset balancing. The scripts indicate the system expects fixed-duration input windows.

#### Speech recognition subsystem

Path: `VoiceAssistant/speechrecognition/`

##### Purpose
This subsystem converts audio into text. The README describes it as a pretrained/fine-tunable ASR model.

##### Main components
- `engine.py`  
  Offline inference/demo entry point for speech recognition.

- `decoder.py`  
  Post-processing / decoding logic for model outputs, likely CTC decoding.

- `neuralnet/`
  - `dataset.py` — audio/text dataset handling
  - `model.py` — ASR model definition
  - `scorer.py` — scoring/evaluation support
  - `train.py` — training and fine-tuning
  - `optimize_graph.py` — exports an inference-ready graph
  - `utils.py` — helper functions
  - `__init__.py` — package boundary

- `demo/`
  - `demo.py` — demo app launcher
  - `templates/demo.html` — web UI for the demo

- `scripts/`
  - `mimic_create_jsons.py` — builds train/test manifests from Mimic Recording Studio output
  - `commonvoice_create_jsons.py` — converts Common Voice data and builds manifests

##### Data flow
The speech recognition path is:
1. ingest audio-text pairs from Mimic Recording Studio or Mozilla Common Voice,
2. optionally convert/normalize audio files,
3. generate train/validation/test JSON manifests,
4. train or fine-tune the ASR model,
5. optimize/export the model,
6. run inference through `engine.py` or the web demo.

##### Architectural notes
This subsystem has the richest inference support:
- a standalone engine for direct testing,
- a demo app with HTML templates for interactive use,
- a decoder layer separating model output from text generation.

The README mentions CTC decoding dependencies, so the architecture is likely based on a sequence model that produces token probabilities, then decodes them into text.

#### NLU subsystem

Path: `VoiceAssistant/nlu/`

##### Purpose
This subsystem interprets recognized text into intent/label predictions. The README labels this as natural language understanding, but the actual functionality appears to be a text classification or intent detection model.

##### Main components
- `engine.py`  
  Inference/demo entry point for NLU.

- `meta_data.bin`  
  Serialized metadata/artifacts used by the NLU model, likely vocabulary, label mappings, or preprocessing state.

- `neuralnet/`
  - `config.py` — model/configuration settings
  - `dataset.py` — dataset preparation
  - `model.py` — model definition
  - `train.py` — training
  - `optimize_graph.py` — export/optimize for inference
  - `utils.py` — helpers
  - `__init__.py`

- `scripts/`
  - `make_dataset.py` — dataset creation from source text examples

- `nlu_dataset/`
  - `er_dataset.csv`
  - `is_dataset.csv`
  - `nlu.csv`
  - `nlucopy.csv`

##### Data flow
The NLU flow is:
1. curate labeled text examples into CSV/dataset files,
2. build training data and metadata,
3. train the classifier,
4. optimize/export the graph,
5. run inference in `engine.py`.

##### Architectural notes
This subsystem is text-only and sits downstream of speech recognition. Its dependency on `meta_data.bin` suggests a stable preprocessing contract between training and inference, such as tokenization or label mapping.

#### Speech synthesis subsystem

Path: `VoiceAssistant/speechsynthesis/`

##### Purpose
This package boundary exists, but there are no visible engine, model, or training files in the provided tree.

##### Architectural role
The README explicitly lists speech synthesis as planned, not completed. In a full assistant pipeline, this subsystem would be the final stage that turns NLU/skills outputs into audio responses.

#### Core assistant integration boundary

Path: `VoiceAssistant/core.py`

##### Purpose
This is likely intended to be the top-level coordinator that wires together:
- wake word detection,
- speech recognition,
- NLU,
- speech synthesis,
- skills/action execution.

##### Architectural role
The README says this integration is still a TODO, so this is more of a future system boundary than a fully realized runtime. In diagram terms, it should be shown as the orchestration layer above the individual ML services/modules.

#### Training vs inference separation

A major architectural pattern across the repo is the split between:
- **training-time code**
- **inference-time code**
- **model export/optimization code**

This pattern appears in wake word, speech recognition, and NLU.

Typical module roles:
- `dataset.py` — prepares examples and batching
- `model.py` — defines the network
- `train.py` — trains from labeled data
- `optimize_graph.py` — converts the trained model to an inference-friendly artifact
- `engine.py` — loads the optimized artifact for demo/runtime use

This separation is important for an architecture diagram because it shows that the repo is not just one application runtime; it also includes the full ML lifecycle.

#### External datasets and tooling

These materially affect the architecture:

- **Mozilla Common Voice**  
  Used for speech recognition and wake word data preparation.

- **Mimic Recording Studio**  
  Used for collecting personalized speech recognition data.

- **PyTorch**  
  The core ML framework used across the neural network packages.

- **CTC decoding library (`ctcdecode`)**  
  Specifically relevant to speech recognition output decoding.

- **PortAudio / PyAudio**  
  Needed for microphone/audio capture in recording and demo workflows.

- **Docker**  
  Two build paths exist:
  - GPU/CUDA container via `Dockerfile`
  - CPU-only container via `cpu.Dockerfile`

These choices imply the repo is designed to run both as a local development environment and as a containerized ML system.

#### Boundaries and dependencies between subsystems

The intended assistant pipeline is:

1. **Wake word engine** listens continuously for activation.
2. Once triggered, **speech recognition** processes the user’s utterance.
3. The recognized text is passed to **NLU** for intent interpretation.
4. A future **skills layer** would decide what action to take.
5. **Speech synthesis** would generate the spoken response.

At present, the repo is more complete on the left side of that pipeline than the right:
- wake word: implemented
- speech recognition: implemented
- NLU: implemented
- synthesis/skills/core orchestration: scaffolded or planned

#### Practical diagramming guidance

If you are drawing an architecture diagram for this repo, the cleanest representation is:

- one top-level “VoiceAssistant” application boundary,
- three major ML subsystems inside it,
- each subsystem split into training/data/inference artifacts,
- a central orchestration layer in `core.py`,
- external dependencies feeding into training and runtime capture,
- Docker and dependency files shown as environment/runtime support, not as core logic.

The most accurate summary is that this repository is an ML system workspace for building a voice assistant, with independent pipelines for wake word detection, ASR, and NLU, but without a finished end-to-end assistant runtime yet.

Main entry points: [`VoiceAssistant/core.py`](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/core.py) (Core), [`VoiceAssistant/speechrecognition/engine.py`](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/engine.py) (ASR engine), [`VoiceAssistant/nlu/engine.py`](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/engine.py) (NLU engine), [`VoiceAssistant/wakeword/engine.py`](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/engine.py) (Wake engine)

## Diagram (Mermaid)

```mermaid
flowchart TD

subgraph group_voiceassistant["VoiceAssistant"]
  node_core["Core<br/>assistant orchestrator<br/>[core.py]"]
  node_synth_pkg["Synthesis pkg<br/>placeholder package<br/>[__init__.py]"]
end

subgraph group_wakeword["Wake word"]
  node_wake_engine["Wake engine<br/>inference entry<br/>[engine.py]"]
  node_wake_dataset["Wake data<br/>dataset prep<br/>[dataset.py]"]
  node_wake_model(("Wake model<br/>classifier model<br/>[model.py]"))
  node_wake_train["Wake train<br/>training<br/>[train.py]"]
  node_wake_opt["Wake export<br/>graph export<br/>[optimize_graph.py]"]
end

subgraph group_asr["Speech recognition"]
  node_asr_engine["ASR engine<br/>inference entry<br/>[engine.py]"]
  node_asr_decoder["Decoder<br/>ctc decode<br/>[decoder.py]"]
  node_asr_dataset["ASR data<br/>dataset prep<br/>[dataset.py]"]
  node_asr_model(("ASR model<br/>seq2seq model<br/>[model.py]"))
  node_asr_train["ASR train<br/>training<br/>[train.py]"]
  node_asr_opt["ASR export<br/>graph export<br/>[optimize_graph.py]"]
  node_asr_demo["ASR demo<br/>web demo<br/>[demo.py]"]
end

subgraph group_nlu["NLU"]
  node_nlu_engine["NLU engine<br/>inference entry<br/>[engine.py]"]
  node_nlu_meta["Metadata<br/>artifact<br/>[meta_data.bin]"]
  node_nlu_dataset["NLU data<br/>dataset<br/>[nlu.csv]"]
  node_nlu_model(("NLU model<br/>text classifier<br/>[model.py]"))
  node_nlu_train["NLU train<br/>training<br/>[train.py]"]
  node_nlu_opt["NLU export<br/>graph export<br/>[optimize_graph.py]"]
end

subgraph group_support["Support"]
  node_env["Env support<br/>runtime packaging"]
  node_audio_samples["Audio samples<br/>demo assets<br/>[Hi.wav]"]
end

node_core -->|"starts"| node_wake_engine
node_core -->|"passes audio"| node_asr_engine
node_core -->|"passes text"| node_nlu_engine
node_core -.->|"responds via"| node_synth_pkg
node_wake_engine -->|"loads"| node_wake_model
node_wake_model -->|"exported from"| node_wake_opt
node_wake_train -->|"trains"| node_wake_model
node_wake_dataset -->|"feeds"| node_wake_train
node_wake_opt -->|"serves"| node_wake_engine
node_asr_engine -->|"decodes through"| node_asr_decoder
node_asr_engine -->|"loads"| node_asr_model
node_asr_model -->|"exported from"| node_asr_opt
node_asr_train -->|"trains"| node_asr_model
node_asr_dataset -->|"feeds"| node_asr_train
node_asr_opt -->|"serves"| node_asr_engine
node_asr_demo -->|"uses"| node_asr_engine
node_nlu_engine -->|"loads"| node_nlu_meta
node_nlu_engine -->|"loads"| node_nlu_model
node_nlu_train -->|"trains"| node_nlu_model
node_nlu_dataset -->|"feeds"| node_nlu_train
node_nlu_opt -->|"serves"| node_nlu_engine
node_env -.->|"supports"| node_core
node_audio_samples -.->|"demo input"| node_wake_engine

click node_core "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/core.py"
click node_wake_engine "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/engine.py"
click node_wake_dataset "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/neuralnet/dataset.py"
click node_wake_model "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/neuralnet/model.py"
click node_wake_train "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/neuralnet/train.py"
click node_wake_opt "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/neuralnet/optimize_graph.py"
click node_asr_engine "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/engine.py"
click node_asr_decoder "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/decoder.py"
click node_asr_dataset "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/neuralnet/dataset.py"
click node_asr_model "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/neuralnet/model.py"
click node_asr_train "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/neuralnet/train.py"
click node_asr_opt "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/neuralnet/optimize_graph.py"
click node_asr_demo "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/demo/demo.py"
click node_nlu_engine "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/engine.py"
click node_nlu_meta "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/meta_data.bin"
click node_nlu_dataset "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/nlu_dataset/nlu.csv"
click node_nlu_model "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/neuralnet/model.py"
click node_nlu_train "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/neuralnet/train.py"
click node_nlu_opt "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/neuralnet/optimize_graph.py"
click node_synth_pkg "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechsynthesis/__init__.py"
click node_env "https://github.com/learnedvector/a-hackers-ai-voice-assistant/tree/master/Dockerfile"
click node_audio_samples "https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/fun/arnold_audio/Hi.wav"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_core,node_synth_pkg toneBlue
class node_wake_engine,node_wake_dataset,node_wake_model,node_wake_train,node_wake_opt toneAmber
class node_asr_engine,node_asr_decoder,node_asr_dataset,node_asr_model,node_asr_train,node_asr_opt,node_asr_demo toneMint
class node_nlu_engine,node_nlu_meta,node_nlu_dataset,node_nlu_model,node_nlu_train,node_nlu_opt toneRose
class node_env,node_audio_samples toneIndigo
```

## Components

### VoiceAssistant

Top-level assistant workspace and ML subsystems

- [Core](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/core.py): assistant orchestrator · Intended top-level integration layer for the assistant pipeline · `VoiceAssistant/core.py`
- [Synthesis pkg](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechsynthesis/__init__.py): placeholder package · Speech synthesis boundary is present but not implemented · `VoiceAssistant/speechsynthesis/__init__.py`

### Wake word

Trigger detection pipeline

- [Wake engine](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/engine.py): inference entry · Runs wake-word detection at runtime · `VoiceAssistant/wakeword/engine.py`
- [Wake data](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/neuralnet/dataset.py): dataset prep · Loads and prepares fixed-window audio examples · `VoiceAssistant/wakeword/neuralnet/dataset.py`
- [Wake model](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/neuralnet/model.py): classifier model · Neural network for wake-word vs background detection · `VoiceAssistant/wakeword/neuralnet/model.py`
- [Wake train](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/neuralnet/train.py): training · Trains the wake-word model from labeled audio · `VoiceAssistant/wakeword/neuralnet/train.py`
- [Wake export](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/wakeword/neuralnet/optimize_graph.py): graph export · Optimizes the trained wake-word model for inference · `VoiceAssistant/wakeword/neuralnet/optimize_graph.py`

### Speech recognition

Audio-to-text pipeline

- [ASR engine](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/engine.py): inference entry · Runs offline speech recognition · `VoiceAssistant/speechrecognition/engine.py`
- [Decoder](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/decoder.py): ctc decode · Converts model outputs into text · `VoiceAssistant/speechrecognition/decoder.py`
- [ASR data](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/neuralnet/dataset.py): dataset prep · Builds audio-text training batches and manifests · `VoiceAssistant/speechrecognition/neuralnet/dataset.py`
- [ASR model](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/neuralnet/model.py): seq2seq model · Speech recognition network · `VoiceAssistant/speechrecognition/neuralnet/model.py`
- [ASR train](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/neuralnet/train.py): training · Trains and fine-tunes the ASR model · `VoiceAssistant/speechrecognition/neuralnet/train.py`
- [ASR export](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/neuralnet/optimize_graph.py): graph export · Optimizes the ASR model for inference/demo use · `VoiceAssistant/speechrecognition/neuralnet/optimize_graph.py`
- [ASR demo](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/speechrecognition/demo/demo.py): web demo · Browser demo entry point and UI · `VoiceAssistant/speechrecognition/demo/demo.py`

### NLU

Text intent classification pipeline

- [NLU engine](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/engine.py): inference entry · Runs intent or label prediction over text · `VoiceAssistant/nlu/engine.py`
- [Metadata](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/meta_data.bin): artifact · Serialized preprocessing and label metadata · `VoiceAssistant/nlu/meta_data.bin`
- [NLU data](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/nlu_dataset/nlu.csv): dataset · Curated labeled text examples · `VoiceAssistant/nlu/nlu_dataset/nlu.csv`
- [NLU model](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/neuralnet/model.py): text classifier · Model for intent or label classification · `VoiceAssistant/nlu/neuralnet/model.py`
- [NLU train](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/neuralnet/train.py): training · Trains the NLU classifier · `VoiceAssistant/nlu/neuralnet/train.py`
- [NLU export](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/VoiceAssistant/nlu/neuralnet/optimize_graph.py): graph export · Optimizes the NLU model for inference · `VoiceAssistant/nlu/neuralnet/optimize_graph.py`

### Support

Packaging, demo assets, and environment support

- [Env support](https://github.com/learnedvector/a-hackers-ai-voice-assistant/tree/master/Dockerfile): runtime packaging · Container and dependency setup for CPU, GPU, and Raspberry Pi environments · `Dockerfile`
- [Audio samples](https://github.com/learnedvector/a-hackers-ai-voice-assistant/blob/master/fun/arnold_audio/Hi.wav): demo assets · Example audio clips used for experimentation and fun demos · `fun/arnold_audio/Hi.wav`

## Connections

- Core → Wake engine: starts · Coordinator begins with wake-word listening
- Core → ASR engine: passes audio · Coordinator routes captured speech to ASR
- Core → NLU engine: passes text · Coordinator forwards recognized text to NLU
- Core → Synthesis pkg: responds via · Future response generation boundary
- Wake engine → Wake model: loads · Inference uses optimized wake-word network
- Wake model → Wake export: exported from · Inference artifact is produced by graph optimization
- Wake train → Wake model: trains · Training produces the wake-word network
- Wake data → Wake train: feeds · Prepared audio windows supply training data
- Wake export → Wake engine: serves · Optimized graph is consumed by runtime engine
- ASR engine → Decoder: decodes through · Model outputs are post-processed into text
- ASR engine → ASR model: loads · Inference uses the ASR network
- ASR model → ASR export: exported from · Inference artifact comes from optimization step
- ASR train → ASR model: trains · Training and fine-tuning produce the ASR network
- ASR data → ASR train: feeds · Audio-text corpora feed training
- ASR export → ASR engine: serves · Optimized ASR graph powers runtime inference
- ASR demo → ASR engine: uses · Web demo wraps the ASR inference path
- NLU engine → Metadata: loads · Runtime relies on saved preprocessing and labels
- NLU engine → NLU model: loads · Inference uses the NLU classifier
- NLU train → NLU model: trains · Training produces the text model
- NLU data → NLU train: feeds · Labeled examples feed classifier training
- NLU export → NLU engine: serves · Optimized graph powers inference
- Env support → Core: supports · Container and dependency setup support execution
- Audio samples → Wake engine: demo input · Sample clips support experimentation
