ParakeetCTC

​

Overview

• Fastest inference among all Parakeet variants
• Simpler architecture (encoder + linear decoder)
• Frame-independent predictions
• Only supports greedy decoding
• No decoder hidden state required
• Good for batch processing of clear audio

​

Class Definition

class ParakeetCTC(BaseParakeet):
    def __init__(self, args: ParakeetCTCArgs):
        ...

​

Inherited Methods

• transcribe() - Transcribe audio files
• transcribe_stream() - Real-time streaming transcription
• generate() - Low-level mel-spectrogram to text

​

CTC-Specific Methods

​

decode()

def decode(
    self,
    features: mx.array,
    lengths: mx.array,
    *,
    config: DecodingConfig = DecodingConfig(),
) -> list[list[AlignedToken]]

​

Parameters

features, lengths = model.encoder(mel)

​

Returns

​

Examples

import mlx.core as mx
from parakeet_mlx import from_pretrained, DecodingConfig
from parakeet_mlx.audio import get_logmel, load_audio
from typing import cast

model = from_pretrained("mlx-community/parakeet-ctc-0.6b")
model_ctc = cast(ParakeetCTC, model)

# Prepare input
audio = load_audio("audio.wav", model.preprocessor_config.sample_rate)
mel = get_logmel(audio, model.preprocessor_config)

# Encode
features, lengths = model.encoder(mel)

# Decode - note: lengths is required
tokens = model_ctc.decode(features, lengths)

# Print tokens
for token in tokens[0]:
    print(f"[{token.start:.2f}s - {token.end:.2f}s] {token.text} (conf: {token.confidence:.2f})")

# Process multiple mel-spectrograms
batch_mel = mx.stack([mel1, mel2, mel3])
features, lengths = model.encoder(batch_mel)

# Decode all at once
tokens_batch = model_ctc.decode(features, lengths)

for i, tokens in enumerate(tokens_batch):
    text = "".join(t.text for t in tokens)
    print(f"Input {i}: {text}")

# generate() internally calls decode()
results = model.generate(mel)

for result in results:
    print(result.text)
    for sentence in result.sentences:
        print(f"  [{sentence.start:.2f}s - {sentence.end:.2f}s] {sentence.text}")

# Get encoder features
features, lengths = model.encoder(mel)

# Get CTC logits before decoding
logits = model_ctc.decoder(features)  # Shape: [batch, sequence, vocab_size+1]
mx.eval(logits)

# Now decode
tokens = model_ctc.decode(features, lengths)

​

Decoding Algorithm

​

CTC Greedy Decoding

1. For each frame, select most likely token (argmax)
2. Remove consecutive duplicates
3. Remove blank tokens
4. Merge adjacent identical tokens
5. Compute token boundaries and confidence

Frame predictions:  [BLANK, H, H, E, E, L, L, BLANK, L, O]
After collapse:     [H, E, L, L, O]
After blank remove: [H, E, L, L, O]

• Token start: First frame where token appears
• Token end: Last frame before next different token
• Duration: Time span between start and end

• Computed using entropy-based method across token frames
• Lower entropy = higher confidence
• Formula: confidence = 1.0 - (avg_entropy / max_entropy)

​

Model Properties

model.vocabulary       # list[str] - Token vocabulary
model.decoder          # ConvASRDecoder - Linear CTC decoder
model.encoder          # Conformer - Encoder network

​

Architecture Details

1. Encoder: Converts mel-spectrogram to features
   features, lengths = model.encoder(mel)  # Shape: [B, T, D]
   
2. Decoder: Linear projection to vocabulary
   logits = model.decoder(features)  # Shape: [B, T, vocab_size+1]
   
   The decoder is just:
   • Optional convolutional layers
   • Linear layer: features → vocab_size + 1 (including blank)
   • Log-softmax for probabilities
3. Decoding: Collapse and remove blanks
   predictions = mx.argmax(logits, axis=-1)  # [B, T]
   # Collapse consecutive duplicates, remove blanks
   tokens = collapse_and_deblanks(predictions)
   

• No decoder RNN forward pass per frame
• No joint network computation
• Simple argmax + collapse operation
• Can be fully parallelized

​

Token Boundaries

# Frame predictions
frames: [BLANK, H, H, H, E, E, L, L, L, BLANK, L, L, O]
         0     1  2  3  4  5  6  7  8   9    10 11 12

# Token boundaries
H: frames 1-3   → start=1*time_ratio, end=4*time_ratio
E: frames 4-5   → start=4*time_ratio, end=6*time_ratio  
L: frames 6-8   → start=6*time_ratio, end=9*time_ratio
L: frames 10-11 → start=10*time_ratio, end=12*time_ratio
O: frames 12    → start=12*time_ratio, end=13*time_ratio

​

Performance Tips

1. Use for batch processing: CTC excels at processing many files at once
2. Best for clear audio: CTC works well when audio quality is good
3. Fastest option: Choose CTC when speed is critical
4. No state management: Simpler to use than TDT/RNNT (no hidden states)
5. Memory efficient: No decoder RNN means less memory usage

​

Streaming with CTC

with model.transcribe_stream() as stream:
    for audio_chunk in audio_chunks:
        stream.add_audio(audio_chunk)
        result = stream.result
        print(result.text)

• No decoder state to track
• Each frame is predicted independently
• Simpler state management in streaming implementation

​

When to Use CTC

• Speed is the top priority
• Audio quality is good
• You’re doing batch processing
• You don’t need maximum accuracy
• Simpler architecture is preferred
• Memory is very constrained

• Accuracy is more important than speed
• Audio quality varies
• You need beam search (TDT)
• You need duration predictions (TDT)
• You want better handling of challenging audio

• CTC: ~2x faster than TDT greedy, ~10x faster than TDT beam
• CTC: 90-95% of TDT accuracy on clear audio
• CTC: Lower relative accuracy on noisy/accented audio

​

Limitations

1. No beam search: Only greedy decoding is available
2. Independence assumption: Each frame is predicted independently, missing some context
3. Alignment quality: Can produce less precise alignments than transducers
4. Challenging audio: Performance degrades more on noisy/accented audio compared to TDT

​

Related

• BaseParakeet - Common interface and methods
• ParakeetTDT - TDT variant (higher accuracy, beam search)
• ParakeetRNNT - RNNT variant (balance of speed and accuracy)
• DecodingConfig - Decoding configuration
• AlignedToken - Token structure
• Performance comparison - Choosing the right model