Upload 14 files

dac_44khz/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

dac_44khz/README.md

@@ -0,0 +1,199 @@
+---
+library_name: transformers
+pipeline_tag: feature-extraction
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]

dac_44khz/config.json

@@ -0,0 +1,31 @@
+{
+  "architectures": [
+    "DacModel"
+  ],
+  "codebook_dim": 8,
+  "codebook_loss_weight": 1.0,
+  "codebook_size": 1024,
+  "commitment_loss_weight": 0.25,
+  "decoder_hidden_size": 1536,
+  "downsampling_ratios": [
+    2,
+    4,
+    8,
+    8
+  ],
+  "encoder_hidden_size": 64,
+  "hidden_size": 1024,
+  "hop_length": 512,
+  "model_type": "dac",
+  "n_codebooks": 9,
+  "quantizer_dropout": 0.0,
+  "sampling_rate": 44100,
+  "torch_dtype": "float32",
+  "transformers_version": "4.42.0.dev0",
+  "upsampling_ratios": [
+    8,
+    8,
+    4,
+    2
+  ]
+}

dac_44khz/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6128ebff483a41422b0164d079a3773b0d8d82e64c4293d775994cbf8baf913a
+size 306507276

dac_44khz/preprocessor_config.json

@@ -0,0 +1,9 @@
+{
+  "feature_extractor_type": "DacFeatureExtractor",
+  "feature_size": 1,
+  "hop_length": 512,
+  "padding_side": "right",
+  "padding_value": 0.0,
+  "return_attention_mask": true,
+  "sampling_rate": 44100
+}

speaker_encoder/config.json

@@ -0,0 +1,43 @@
+{
+  "architectures": [
+    "EcapaTdnnSpeakerEncoder"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_ecapa_tdnn.EcapaTdnnSpeakerEncoderConfig",
+    "AutoModel": "modeling_ecapa_tdnn.EcapaTdnnSpeakerEncoder",
+    "AutoModelForFeatureExtraction": "modeling_ecapa_tdnn.EcapaTdnnSpeakerEncoder",
+    "AutoFeatureExtractor": "feature_extraction_ecapa_tdnn.EcapaTdnnFeatureExtractor",
+    "AutoTokenizer": "tokenizer_ecapa_tdnn.EcapaTdnnDummyTokenizer"
+  },
+  "model_type": "ecapa_tdnn_speaker_encoder",
+  "mel_dim": 128,
+  "enc_dim": 2048,
+  "enc_channels": [
+    512,
+    512,
+    512,
+    512,
+    1536
+  ],
+  "enc_kernel_sizes": [
+    5,
+    3,
+    3,
+    3,
+    1
+  ],
+  "enc_dilations": [
+    1,
+    2,
+    3,
+    4,
+    1
+  ],
+  "enc_attention_channels": 128,
+  "enc_res2net_scale": 8,
+  "enc_se_channels": 128,
+  "sample_rate": 24000,
+  "pipeline_tag": "feature-extraction",
+  "torch_dtype": "float32",
+  "feature_extractor_type": "EcapaTdnnFeatureExtractor"
+}

speaker_encoder/configuration_ecapa_tdnn.py

@@ -0,0 +1,66 @@
+"""ECAPA-TDNN Speaker Encoder configuration.
+
+Standalone configuration for the ECAPA-TDNN speaker encoder extracted from
+Qwen3-TTS. Compatible with the HuggingFace transformers AutoModel API.
+"""
+
+from transformers import PretrainedConfig
+
+
+class EcapaTdnnSpeakerEncoderConfig(PretrainedConfig):
+    r"""
+    Configuration class for the ECAPA-TDNN speaker encoder.
+
+    This model produces fixed-dimensional speaker embeddings (x-vectors) from
+    log-mel spectrograms. The architecture follows the ECAPA-TDNN paper:
+    "Emphasized Channel Attention, Propagation and Aggregation in TDNN Based
+    Speaker Verification" (https://arxiv.org/abs/2005.07143).
+
+    Args:
+        mel_dim (`int`, *optional*, defaults to 128):
+            Number of mel-frequency bins in the input spectrogram.
+        enc_dim (`int`, *optional*, defaults to 1024):
+            Dimension of the output speaker embedding.
+        enc_channels (`list[int]`, *optional*, defaults to `[512, 512, 512, 512, 1536]`):
+            Output channels for each encoder layer. The first is the initial
+            TDNN layer, the middle ones are SE-Res2Net blocks, and the last is
+            the multi-layer feature aggregation layer.
+        enc_kernel_sizes (`list[int]`, *optional*, defaults to `[5, 3, 3, 3, 1]`):
+            Kernel sizes for each encoder layer.
+        enc_dilations (`list[int]`, *optional*, defaults to `[1, 2, 3, 4, 1]`):
+            Dilation rates for each encoder layer.
+        enc_attention_channels (`int`, *optional*, defaults to 128):
+            Number of attention channels in the attentive statistics pooling layer.
+        enc_res2net_scale (`int`, *optional*, defaults to 8):
+            Scale factor for the Res2Net blocks.
+        enc_se_channels (`int`, *optional*, defaults to 128):
+            Number of channels in the squeeze-excitation bottleneck.
+        sample_rate (`int`, *optional*, defaults to 24000):
+            Expected audio sample rate in Hz.
+    """
+
+    model_type = "ecapa_tdnn_speaker_encoder"
+
+    def __init__(
+        self,
+        mel_dim=128,
+        enc_dim=1024,
+        enc_channels=None,
+        enc_kernel_sizes=None,
+        enc_dilations=None,
+        enc_attention_channels=128,
+        enc_res2net_scale=8,
+        enc_se_channels=128,
+        sample_rate=24000,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.mel_dim = mel_dim
+        self.enc_dim = enc_dim
+        self.enc_channels = enc_channels if enc_channels is not None else [512, 512, 512, 512, 1536]
+        self.enc_kernel_sizes = enc_kernel_sizes if enc_kernel_sizes is not None else [5, 3, 3, 3, 1]
+        self.enc_dilations = enc_dilations if enc_dilations is not None else [1, 2, 3, 4, 1]
+        self.enc_attention_channels = enc_attention_channels
+        self.enc_res2net_scale = enc_res2net_scale
+        self.enc_se_channels = enc_se_channels
+        self.sample_rate = sample_rate

speaker_encoder/feature_extraction_ecapa_tdnn.py

@@ -0,0 +1,141 @@
+"""Feature extractor for the ECAPA-TDNN speaker encoder.
+
+Converts raw audio waveforms into log-mel spectrograms suitable for the
+ECAPA-TDNN speaker encoder model.
+"""
+
+import numpy as np
+import torch
+from transformers.feature_extraction_utils import BatchFeature, FeatureExtractionMixin
+
+
+class EcapaTdnnFeatureExtractor(FeatureExtractionMixin):
+    r"""
+    Feature extractor for ECAPA-TDNN speaker encoder models.
+
+    Converts raw audio waveforms to 128-bin log-mel spectrograms matching the
+    Qwen3-TTS preprocessing pipeline.
+
+    Args:
+        sample_rate (`int`, defaults to 24000):
+            Target sample rate in Hz. Audio will be resampled if needed.
+        n_fft (`int`, defaults to 1024):
+            FFT window size.
+        hop_length (`int`, defaults to 256):
+            Hop length between STFT frames.
+        n_mels (`int`, defaults to 128):
+            Number of mel-frequency bins.
+        fmin (`float`, defaults to 0):
+            Minimum frequency for mel filterbank.
+        fmax (`float`, defaults to 12000):
+            Maximum frequency for mel filterbank.
+    """
+
+    model_input_names = ["input_values"]
+
+    def __init__(
+        self,
+        sample_rate=24000,
+        n_fft=1024,
+        hop_length=256,
+        n_mels=128,
+        fmin=0,
+        fmax=12000,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.sample_rate = sample_rate
+        self.sampling_rate = sample_rate  # alias for HF pipeline compatibility
+        self.n_fft = n_fft
+        self.hop_length = hop_length
+        self.n_mels = n_mels
+        self.fmin = fmin
+        self.fmax = fmax
+
+    def __call__(self, raw_speech, sampling_rate=None, return_tensors="pt", **kwargs):
+        """
+        Process raw audio waveform(s) into log-mel spectrogram features.
+
+        Args:
+            raw_speech (`np.ndarray`, `list[np.ndarray]`, or file path `str`):
+                Raw audio waveform(s) as float32 numpy array(s), or a file path.
+            sampling_rate (`int`, *optional*):
+                Sample rate of the input audio. Resampled to ``self.sample_rate``
+                if different.
+            return_tensors (`str`, defaults to ``"pt"``):
+                Return type — ``"pt"`` for PyTorch tensors.
+
+        Returns:
+            ``BatchFeature`` with ``input_values`` key containing the log-mel
+            spectrogram tensor of shape ``(batch, time, n_mels)``.
+        """
+        # Handle single input
+        if isinstance(raw_speech, str):
+            import librosa
+            raw_speech, sampling_rate = librosa.load(raw_speech, sr=None, mono=True)
+
+        if isinstance(raw_speech, np.ndarray) and raw_speech.ndim == 1:
+            raw_speech = [raw_speech]
+
+        features = []
+        for audio in raw_speech:
+            if isinstance(audio, str):
+                import librosa
+                audio, sampling_rate = librosa.load(audio, sr=None, mono=True)
+
+            mel = self._compute_mel(audio, sampling_rate or self.sample_rate)
+            features.append(mel)
+
+        # Pad to same length
+        max_len = max(f.shape[1] for f in features)
+        padded = []
+        for f in features:
+            if f.shape[1] < max_len:
+                f = torch.nn.functional.pad(f, (0, 0, 0, max_len - f.shape[1]))
+            padded.append(f)
+
+        input_values = torch.cat(padded, dim=0)
+        return BatchFeature({"input_values": input_values})
+
+    def _compute_mel(self, audio, sr):
+        """Compute 128-bin log-mel spectrogram matching Qwen3-TTS requirements."""
+        import librosa
+        from librosa.filters import mel as librosa_mel_fn
+
+        if isinstance(audio, torch.Tensor):
+            audio = audio.numpy()
+
+        if sr != self.sample_rate:
+            audio = librosa.resample(
+                audio.astype(np.float32), orig_sr=sr, target_sr=self.sample_rate
+            )
+
+        y = torch.from_numpy(audio).unsqueeze(0).float()
+        mel_basis = torch.from_numpy(
+            librosa_mel_fn(
+                sr=self.sample_rate,
+                n_fft=self.n_fft,
+                n_mels=self.n_mels,
+                fmin=self.fmin,
+                fmax=self.fmax,
+            )
+        ).float()
+
+        padding = (self.n_fft - self.hop_length) // 2
+        y = torch.nn.functional.pad(
+            y.unsqueeze(1), (padding, padding), mode="reflect"
+        ).squeeze(1)
+        hann = torch.hann_window(self.n_fft)
+        spec = torch.stft(
+            y,
+            self.n_fft,
+            hop_length=self.hop_length,
+            win_length=self.n_fft,
+            window=hann,
+            center=False,
+            return_complex=True,
+        )
+        spec = torch.abs(spec)
+        mel = torch.matmul(mel_basis, spec)
+        mel = torch.log(torch.clamp(mel, min=1e-5))
+        return mel.transpose(1, 2)  # (1, time, n_mels)

speaker_encoder/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df60a638e7f4a29331c0af2bd2984ee5b992fee9d5923c776f7e4bdc3dedea48
+size 24010000

speaker_encoder/modeling_ecapa_tdnn.py

@@ -0,0 +1,284 @@
+"""ECAPA-TDNN Speaker Encoder model.
+
+Standalone implementation of the ECAPA-TDNN speaker encoder extracted from
+Qwen3-TTS. Produces fixed-dimensional x-vector speaker embeddings from
+log-mel spectrogram input.
+
+Architecture: ECAPA-TDNN (Emphasized Channel Attention, Propagation and
+Aggregation in TDNN Based Speaker Verification)
+Paper: https://arxiv.org/abs/2005.07143
+
+This file is self-contained and depends only on torch and transformers.
+"""
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import BaseModelOutputWithNoAttention
+
+from .configuration_ecapa_tdnn import EcapaTdnnSpeakerEncoderConfig
+
+
+class TimeDelayNetBlock(nn.Module):
+    """1-D convolution + ReLU (TDNN layer)."""
+
+    def __init__(self, in_channels, out_channels, kernel_size, dilation):
+        super().__init__()
+        self.conv = nn.Conv1d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            dilation=dilation,
+            padding="same",
+            padding_mode="reflect",
+        )
+        self.activation = nn.ReLU()
+
+    def forward(self, hidden_states: torch.Tensor):
+        return self.activation(self.conv(hidden_states))
+
+
+class Res2NetBlock(nn.Module):
+    """Multi-scale Res2Net block using TDNN sub-blocks."""
+
+    def __init__(self, in_channels, out_channels, scale=8, kernel_size=3, dilation=1):
+        super().__init__()
+        in_channel = in_channels // scale
+        hidden_channel = out_channels // scale
+        self.blocks = nn.ModuleList(
+            [
+                TimeDelayNetBlock(in_channel, hidden_channel, kernel_size=kernel_size, dilation=dilation)
+                for _ in range(scale - 1)
+            ]
+        )
+        self.scale = scale
+
+    def forward(self, hidden_states):
+        outputs = []
+        for i, hidden_part in enumerate(torch.chunk(hidden_states, self.scale, dim=1)):
+            if i == 0:
+                output_part = hidden_part
+            elif i == 1:
+                output_part = self.blocks[i - 1](hidden_part)
+            else:
+                output_part = self.blocks[i - 1](hidden_part + output_part)
+            outputs.append(output_part)
+        return torch.cat(outputs, dim=1)
+
+
+class SqueezeExcitationBlock(nn.Module):
+    """Channel-wise squeeze-and-excitation attention."""
+
+    def __init__(self, in_channels, se_channels, out_channels):
+        super().__init__()
+        self.conv1 = nn.Conv1d(
+            in_channels=in_channels,
+            out_channels=se_channels,
+            kernel_size=1,
+            padding="same",
+            padding_mode="reflect",
+        )
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv1d(
+            in_channels=se_channels,
+            out_channels=out_channels,
+            kernel_size=1,
+            padding="same",
+            padding_mode="reflect",
+        )
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, hidden_states):
+        hidden_states_mean = hidden_states.mean(dim=2, keepdim=True)
+        hidden_states_mean = self.relu(self.conv1(hidden_states_mean))
+        hidden_states_mean = self.sigmoid(self.conv2(hidden_states_mean))
+        return hidden_states * hidden_states_mean
+
+
+class SqueezeExcitationRes2NetBlock(nn.Module):
+    """ECAPA-TDNN building block: TDNN → Res2Net → TDNN → SE, with residual."""
+
+    def __init__(self, in_channels, out_channels, res2net_scale=8, se_channels=128, kernel_size=1, dilation=1):
+        super().__init__()
+        self.out_channels = out_channels
+        self.tdnn1 = TimeDelayNetBlock(in_channels, out_channels, kernel_size=1, dilation=1)
+        self.res2net_block = Res2NetBlock(out_channels, out_channels, res2net_scale, kernel_size, dilation)
+        self.tdnn2 = TimeDelayNetBlock(out_channels, out_channels, kernel_size=1, dilation=1)
+        self.se_block = SqueezeExcitationBlock(out_channels, se_channels, out_channels)
+
+    def forward(self, hidden_state):
+        residual = hidden_state
+        hidden_state = self.tdnn1(hidden_state)
+        hidden_state = self.res2net_block(hidden_state)
+        hidden_state = self.tdnn2(hidden_state)
+        hidden_state = self.se_block(hidden_state)
+        return hidden_state + residual
+
+
+class AttentiveStatisticsPooling(nn.Module):
+    """Attentive statistics pooling — produces concatenated weighted mean and std."""
+
+    def __init__(self, channels, attention_channels=128):
+        super().__init__()
+        self.eps = 1e-12
+        self.tdnn = TimeDelayNetBlock(channels * 3, attention_channels, 1, 1)
+        self.tanh = nn.Tanh()
+        self.conv = nn.Conv1d(
+            in_channels=attention_channels,
+            out_channels=channels,
+            kernel_size=1,
+            padding="same",
+            padding_mode="reflect",
+        )
+
+    @staticmethod
+    def _length_to_mask(length, max_len=None, dtype=None, device=None):
+        if max_len is None:
+            max_len = length.max().long().item()
+        mask = torch.arange(max_len, device=length.device, dtype=length.dtype).expand(
+            len(length), max_len
+        ) < length.unsqueeze(1)
+        return torch.as_tensor(mask, dtype=dtype, device=device)
+
+    def _compute_statistics(self, x, m, dim=2):
+        mean = (m * x).sum(dim)
+        std = torch.sqrt((m * (x - mean.unsqueeze(dim)).pow(2)).sum(dim).clamp(self.eps))
+        return mean, std
+
+    def forward(self, hidden_states):
+        seq_length = hidden_states.shape[-1]
+        lengths = torch.ones(hidden_states.shape[0], device=hidden_states.device)
+
+        mask = self._length_to_mask(
+            lengths * seq_length, max_len=seq_length, dtype=hidden_states.dtype, device=hidden_states.device
+        )
+        mask = mask.unsqueeze(1)
+
+        total = mask.sum(dim=2, keepdim=True)
+        mean, std = self._compute_statistics(hidden_states, mask / total)
+        mean = mean.unsqueeze(2).repeat(1, 1, seq_length)
+        std = std.unsqueeze(2).repeat(1, 1, seq_length)
+        attention = torch.cat([hidden_states, mean, std], dim=1)
+
+        attention = self.conv(self.tanh(self.tdnn(attention)))
+        attention = attention.masked_fill(mask == 0, float("-inf"))
+        attention = F.softmax(attention, dim=2)
+
+        mean, std = self._compute_statistics(hidden_states, attention)
+        pooled_stats = torch.cat((mean, std), dim=1)
+        pooled_stats = pooled_stats.unsqueeze(2)
+        return pooled_stats
+
+
+class EcapaTdnnSpeakerEncoderPreTrainedModel(PreTrainedModel):
+    config_class = EcapaTdnnSpeakerEncoderConfig
+    base_model_prefix = "encoder"
+
+    def _init_weights(self, module):
+        std = 0.02
+        if isinstance(module, (nn.Linear, nn.Conv1d)):
+            module.weight.data.normal_(mean=0.0, std=std)
+            if module.bias is not None:
+                module.bias.data.zero_()
+
+
+class EcapaTdnnSpeakerEncoder(EcapaTdnnSpeakerEncoderPreTrainedModel):
+    """ECAPA-TDNN speaker encoder.
+
+    Takes a log-mel spectrogram of shape ``(batch, time, mel_dim)`` and returns
+    a fixed-dimensional speaker embedding of shape ``(batch, enc_dim)``.
+
+    This is a standalone extraction of the speaker encoder from Qwen3-TTS,
+    compatible with the HuggingFace ``AutoModel`` API.
+    """
+
+    def __init__(self, config: EcapaTdnnSpeakerEncoderConfig):
+        super().__init__(config)
+
+        if len(config.enc_channels) != len(config.enc_kernel_sizes) or len(config.enc_channels) != len(
+            config.enc_dilations
+        ):
+            raise ValueError("enc_channels, enc_kernel_sizes and enc_dilations must have the same length")
+
+        self.channels = config.enc_channels
+        self.blocks = nn.ModuleList()
+
+        # Initial TDNN layer
+        self.blocks.append(
+            TimeDelayNetBlock(
+                config.mel_dim,
+                config.enc_channels[0],
+                config.enc_kernel_sizes[0],
+                config.enc_dilations[0],
+            )
+        )
+
+        # SE-Res2Net layers
+        for i in range(1, len(config.enc_channels) - 1):
+            self.blocks.append(
+                SqueezeExcitationRes2NetBlock(
+                    config.enc_channels[i - 1],
+                    config.enc_channels[i],
+                    res2net_scale=config.enc_res2net_scale,
+                    se_channels=config.enc_se_channels,
+                    kernel_size=config.enc_kernel_sizes[i],
+                    dilation=config.enc_dilations[i],
+                )
+            )
+
+        # Multi-layer feature aggregation
+        self.mfa = TimeDelayNetBlock(
+            config.enc_channels[-1],
+            config.enc_channels[-1],
+            config.enc_kernel_sizes[-1],
+            config.enc_dilations[-1],
+        )
+
+        # Attentive Statistical Pooling
+        self.asp = AttentiveStatisticsPooling(
+            config.enc_channels[-1],
+            attention_channels=config.enc_attention_channels,
+        )
+
+        # Final linear transformation
+        self.fc = nn.Conv1d(
+            in_channels=config.enc_channels[-1] * 2,
+            out_channels=config.enc_dim,
+            kernel_size=1,
+            padding="same",
+            padding_mode="reflect",
+        )
+
+        self.post_init()
+
+    def forward(self, input_values=None, **kwargs):
+        """
+        Args:
+            input_values: Log-mel spectrogram tensor of shape ``(batch, time, mel_dim)``.
+
+        Returns:
+            ``BaseModelOutputWithNoAttention`` with ``last_hidden_state`` of shape
+            ``(batch, enc_dim)``.
+        """
+        hidden_states = input_values
+        # Transpose to (batch, channels, time) for Conv1d
+        hidden_states = hidden_states.transpose(1, 2)
+
+        hidden_states_list = []
+        for layer in self.blocks:
+            hidden_states = layer(hidden_states)
+            hidden_states_list.append(hidden_states)
+
+        # Multi-layer feature aggregation
+        hidden_states = torch.cat(hidden_states_list[1:], dim=1)
+        hidden_states = self.mfa(hidden_states)
+
+        # Attentive Statistical Pooling
+        hidden_states = self.asp(hidden_states)
+
+        # Final linear transformation
+        hidden_states = self.fc(hidden_states)
+        hidden_states = hidden_states.squeeze(-1)
+
+        return BaseModelOutputWithNoAttention(last_hidden_state=hidden_states)

speaker_encoder/preprocessor_config.json

@@ -0,0 +1,12 @@
+{
+  "feature_extractor_type": "EcapaTdnnFeatureExtractor",
+  "auto_map": {
+    "AutoFeatureExtractor": "feature_extraction_ecapa_tdnn.EcapaTdnnFeatureExtractor"
+  },
+  "sample_rate": 24000,
+  "n_fft": 1024,
+  "hop_length": 256,
+  "n_mels": 128,
+  "fmin": 0,
+  "fmax": 12000
+}

speaker_encoder/tokenizer_config.json

@@ -0,0 +1,9 @@
+{
+  "tokenizer_class": "EcapaTdnnDummyTokenizer",
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenizer_ecapa_tdnn.EcapaTdnnDummyTokenizer",
+      null
+    ]
+  }
+}

speaker_encoder/tokenizer_ecapa_tdnn.py

@@ -0,0 +1,77 @@
+"""Dummy tokenizer for pipeline("feature-extraction") compatibility.
+
+The HuggingFace ``FeatureExtractionPipeline`` unconditionally requires a
+tokenizer, even for audio models that have no vocabulary.  This thin wrapper
+satisfies that interface by delegating ``__call__`` to the real
+``EcapaTdnnFeatureExtractor``, which computes log-mel spectrograms from raw
+audio.
+
+>>> pipe = pipeline("feature-extraction", model=model_id, trust_remote_code=True)
+>>> pipe("audio.wav")  # works!
+"""
+
+import os
+
+import numpy as np
+from transformers import PreTrainedTokenizer
+from transformers.feature_extraction_utils import BatchFeature
+
+
+class EcapaTdnnDummyTokenizer(PreTrainedTokenizer):
+    """Tokenizer shim that wraps :class:`EcapaTdnnFeatureExtractor`.
+
+    This class exists *only* to make ``pipeline("feature-extraction")`` work
+    with ECAPA-TDNN speaker encoder models.  It contains no real vocabulary —
+    all audio preprocessing is handled by the feature extractor.
+    """
+
+    vocab_files_names: dict[str, str] = {}
+    model_input_names = ["input_values"]
+
+    def __init__(self, **kwargs):
+        # Filter out tokenizer-specific kwargs that don't apply to us
+        kwargs.pop("added_tokens_decoder", None)
+        super().__init__(**kwargs)
+
+    # -- abstract method stubs (unused but required) -----------------------
+
+    @property
+    def vocab_size(self) -> int:
+        return 0
+
+    def get_vocab(self) -> dict[str, int]:
+        return {}
+
+    def _tokenize(self, text, **kwargs):
+        return []
+
+    def _convert_token_to_id(self, token):
+        return 0
+
+    def _convert_id_to_token(self, index):
+        return ""
+
+    def save_vocabulary(self, save_directory, filename_prefix=None):
+        return ()
+
+    # -- the only method that actually matters ------------------------------
+
+    def __call__(self, raw_speech, return_tensors="pt", **kwargs):
+        """Preprocess audio via the feature extractor.
+
+        Accepts the same inputs as :class:`EcapaTdnnFeatureExtractor`:
+        file paths, numpy arrays, or lists thereof.
+        """
+        try:
+            from .feature_extraction_ecapa_tdnn import EcapaTdnnFeatureExtractor
+        except ImportError:
+            from feature_extraction_ecapa_tdnn import EcapaTdnnFeatureExtractor
+
+        # Load the feature extractor config from the same directory
+        model_dir = os.path.dirname(os.path.abspath(__file__))
+        try:
+            fe = EcapaTdnnFeatureExtractor.from_pretrained(model_dir)
+        except Exception:
+            fe = EcapaTdnnFeatureExtractor()
+
+        return fe(raw_speech, return_tensors=return_tensors, **kwargs)

zonos2-fp8-mixed.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:326e1d68c66cde0af14c27570edfdbf2d339be50ce3d6fafb8778ceaf3f9381a
+size 10504655360