wav2vec2-base-960h

Converts raw audio waveforms to text using a self-supervised wav2vec2 architecture that first learns universal speech representations from 960 hours of unlabeled LibriSpeech audio, then fine-tunes a linear classification head on labeled data to map acoustic frames to phonemes/characters. The model uses a multi-layer convolutional feature extractor followed by a transformer encoder with quantized codebook learning, enabling it to capture both low-level acoustic patterns and high-level linguistic structure without requiring phonetic annotations during pretraining.

Processes multiple variable-length audio samples in a single forward pass by dynamically padding shorter sequences to match the longest sample in the batch, then applying attention masks to prevent the model from attending to padded regions. The implementation uses HuggingFace's feature extractor to normalize audio amplitude and convert to mel-spectrogram-like representations, with optional mixed-precision (FP16) computation to reduce memory footprint by 50% while maintaining numerical stability through gradient scaling.

Extracts learned acoustic representations from raw audio by passing waveforms through a 7-layer convolutional feature extractor (stride=5, kernel=10) that downsamples audio by 320x, then applies layer normalization and passes through a 12-layer transformer encoder with 768 hidden dimensions. The model learns to extract phonetically-relevant features during self-supervised pretraining on unlabeled audio, producing contextualized embeddings that capture both local acoustic properties (formants, pitch) and long-range linguistic dependencies (phoneme context, word boundaries).

During pretraining, the model learns a discrete codebook of 320 quantized vectors (product quantization with 2 groups of 160 codes each) that represent prototypical acoustic patterns. For each audio frame, the model's quantizer selects the nearest codebook entry using straight-through estimators for gradient flow, forcing the model to compress continuous acoustic signals into discrete units. This quantization acts as a bottleneck that encourages the feature extractor to learn invariant representations, similar to how vector quantization works in VQ-VAE architectures.

Adapts the pretrained wav2vec2 model to the speech recognition task by adding a linear projection layer that maps 768-dimensional hidden states to a vocabulary of 32 characters (a-z, space, apostrophe, pipe for word boundaries). Training uses Connectionist Temporal Classification (CTC) loss, which aligns variable-length audio sequences to variable-length character sequences without requiring frame-level annotations. CTC marginalizes over all possible alignments, allowing the model to learn where to place character boundaries automatically from only transcript-level supervision.

Supports inference on both CPU and GPU hardware with automatic device placement and mixed-precision computation. On GPU, uses FP16 (half-precision) computation to reduce memory footprint by 50% and increase throughput by 2-3x through tensor cores, with automatic gradient scaling to prevent underflow. On CPU, falls back to FP32 computation with optional quantization (INT8) for 4x memory reduction at the cost of ~1-2% accuracy loss. The implementation uses PyTorch's native device abstraction, allowing seamless switching between hardware without code changes.

Although trained only on English LibriSpeech data, the model's self-supervised pretraining on raw audio learns universal acoustic patterns that transfer to other languages. The learned feature extractor captures language-agnostic properties (pitch, formants, spectral structure) that generalize across linguistic boundaries. Fine-tuning on small amounts of target-language data (1-10 hours) achieves reasonable accuracy without retraining from scratch, because the transformer encoder has already learned to extract relevant acoustic information. This transfer learning approach reduces labeled data requirements for new languages by 10-100x compared to training from scratch.

Enables real-time transcription of streaming audio by processing fixed-size chunks (e.g., 1-second windows) sequentially without buffering the entire audio file. The transformer encoder uses causal masking (attending only to past and current frames, not future frames) to ensure that predictions for each chunk depend only on previously-seen audio. Overlapping chunks (e.g., 50% overlap) are used to maintain context across chunk boundaries, preventing transcription artifacts at chunk edges. The implementation accumulates predictions across chunks and applies post-processing (removing duplicate characters, merging overlapping predictions) to produce coherent transcriptions.