Add files using upload-large-folder tool

README.md

@@ -0,0 +1,39 @@
+---
+language:
+- zh
+license: apache-2.0
+library_name: transformers
+pipeline_tag: audio-classification
+tags:
+- accent-recognition
+- speaker-disentanglement
+- wav2vec2
+---
+
+# GenAID
+
+GenAID is a Chinese accent encoder based on `facebook/wav2vec2-large-xlsr-53`. It produces a 64-dimensional accent embedding designed to reduce speaker information. The model recognizes nine labels: north, Sichuan, Guangdong, south, Henan, Shanghai, Wuhan, Tianjin, and Singapore.
+
+## Usage
+
+```python
+import librosa
+import torch
+from transformers import AutoFeatureExtractor, AutoModel
+
+repo = "walston/GenAID"
+processor = AutoFeatureExtractor.from_pretrained(repo)
+model = AutoModel.from_pretrained(repo, trust_remote_code=True).cuda().eval()
+
+wav, _ = librosa.load("audio.wav", sr=16000, mono=True)
+inputs = processor(wav, sampling_rate=16000, return_tensors="pt")
+inputs = {key: value.cuda() for key, value in inputs.items()}
+
+with torch.inference_mode():
+    output = model(**inputs)
+
+accent_embedding = output.embedding       # [batch, 64]
+accent_logits = output.accent_logits       # [batch, 9]
+```
+
+Loading this repository requires `trust_remote_code=True` because it includes the small GenAID bottleneck and classification heads around the standard XLS-R encoder.

config.json

@@ -0,0 +1,157 @@
+{
+  "accent_labels": [
+    "north",
+    "Sichuan",
+    "Guangdong",
+    "south",
+    "Henan",
+    "Shanghai",
+    "Wuhan",
+    "Tianjin",
+    "singapore"
+  ],
+  "architectures": [
+    "GenAIDModel"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_genaid.GenAIDConfig",
+    "AutoModel": "modeling_genaid.GenAIDModel"
+  },
+  "bottleneck_dim": 64,
+  "encoder_config": {
+    "_name_or_path": "facebook/wav2vec2-large-xlsr-53",
+    "activation_dropout": 0.0,
+    "adapter_attn_dim": null,
+    "adapter_kernel_size": 3,
+    "adapter_stride": 2,
+    "add_adapter": false,
+    "apply_spec_augment": true,
+    "architectures": [
+      "Wav2Vec2ForPreTraining"
+    ],
+    "attention_dropout": 0.1,
+    "bos_token_id": 1,
+    "chunk_size_feed_forward": 0,
+    "classifier_proj_size": 256,
+    "codevector_dim": 768,
+    "contrastive_logits_temperature": 0.1,
+    "conv_bias": true,
+    "conv_dim": [
+      512,
+      512,
+      512,
+      512,
+      512,
+      512,
+      512
+    ],
+    "conv_kernel": [
+      10,
+      3,
+      3,
+      3,
+      3,
+      2,
+      2
+    ],
+    "conv_stride": [
+      5,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2
+    ],
+    "ctc_loss_reduction": "sum",
+    "ctc_zero_infinity": false,
+    "diversity_loss_weight": 0.1,
+    "do_stable_layer_norm": true,
+    "dtype": null,
+    "eos_token_id": 2,
+    "feat_extract_activation": "gelu",
+    "feat_extract_dropout": 0.0,
+    "feat_extract_norm": "layer",
+    "feat_proj_dropout": 0.1,
+    "feat_quantizer_dropout": 0.0,
+    "final_dropout": 0.0,
+    "gradient_checkpointing": false,
+    "hidden_act": "gelu",
+    "hidden_dropout": 0.1,
+    "hidden_size": 1024,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "intermediate_size": 4096,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_eps": 1e-05,
+    "layerdrop": 0.1,
+    "mask_channel_length": 10,
+    "mask_channel_min_space": 1,
+    "mask_channel_other": 0.0,
+    "mask_channel_prob": 0.0,
+    "mask_channel_selection": "static",
+    "mask_feature_length": 10,
+    "mask_feature_min_masks": 0,
+    "mask_feature_prob": 0.0,
+    "mask_time_length": 10,
+    "mask_time_min_masks": 2,
+    "mask_time_min_space": 1,
+    "mask_time_other": 0.0,
+    "mask_time_prob": 0.075,
+    "mask_time_selection": "static",
+    "model_type": "wav2vec2",
+    "num_adapter_layers": 3,
+    "num_attention_heads": 16,
+    "num_codevector_groups": 2,
+    "num_codevectors_per_group": 320,
+    "num_conv_pos_embedding_groups": 16,
+    "num_conv_pos_embeddings": 128,
+    "num_feat_extract_layers": 7,
+    "num_hidden_layers": 24,
+    "num_negatives": 100,
+    "output_attentions": false,
+    "output_hidden_size": 1024,
+    "output_hidden_states": false,
+    "pad_token_id": 0,
+    "problem_type": null,
+    "proj_codevector_dim": 768,
+    "return_dict": true,
+    "tdnn_dilation": [
+      1,
+      2,
+      3,
+      1,
+      1
+    ],
+    "tdnn_dim": [
+      512,
+      512,
+      512,
+      512,
+      1500
+    ],
+    "tdnn_kernel": [
+      5,
+      3,
+      3,
+      1,
+      1
+    ],
+    "transformers_version": "5.15.0",
+    "use_weighted_layer_sum": false,
+    "vocab_size": 32,
+    "xvector_output_dim": 512
+  },
+  "model_type": "genaid",
+  "num_accents": 9,
+  "num_speakers": 336,
+  "sampling_rate": 16000,
+  "transformers_version": "5.15.0"
+}

configuration_genaid.py

@@ -0,0 +1,23 @@
+from transformers import PreTrainedConfig
+
+
+class GenAIDConfig(PreTrainedConfig):
+    model_type = "genaid"
+
+    def __init__(
+        self,
+        encoder_config=None,
+        bottleneck_dim=64,
+        num_accents=9,
+        num_speakers=336,
+        accent_labels=None,
+        sampling_rate=16000,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.encoder_config = encoder_config or {}
+        self.bottleneck_dim = bottleneck_dim
+        self.num_accents = num_accents
+        self.num_speakers = num_speakers
+        self.accent_labels = accent_labels or []
+        self.sampling_rate = sampling_rate

model.safetensors

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

modeling_genaid.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass
+from typing import Optional
+
+import torch
+from torch import nn
+from transformers import AutoConfig, AutoModel, PreTrainedModel
+from transformers.utils import ModelOutput
+
+from .configuration_genaid import GenAIDConfig
+
+
+@dataclass
+class GenAIDOutput(ModelOutput):
+    embedding: torch.FloatTensor = None
+    accent_logits: Optional[torch.FloatTensor] = None
+    speaker_logits: Optional[torch.FloatTensor] = None
+
+
+class GenAIDModel(PreTrainedModel):
+    config_class = GenAIDConfig
+    base_model_prefix = "genaid"
+    main_input_name = "input_values"
+    # GenAID has no tied parameters. Transformers 5.x expects custom models to
+    # expose this mapping while finalizing low-memory checkpoint loading.
+    all_tied_weights_keys = {}
+
+    def __init__(self, config):
+        super().__init__(config)
+        encoder_dict = dict(config.encoder_config)
+        model_type = encoder_dict.pop("model_type")
+        encoder_config = AutoConfig.for_model(model_type, **encoder_dict)
+        self.encoder = AutoModel.from_config(encoder_config)
+        hidden = encoder_config.hidden_size
+        dim = config.bottleneck_dim
+        self.bottleneck = nn.Sequential(
+            nn.Linear(hidden, dim), nn.GELU(), nn.Linear(dim, dim), nn.GELU()
+        )
+        self.accent_classifier = nn.Linear(dim, config.num_accents, bias=False)
+        self.speaker_classifier = nn.Linear(dim, config.num_speakers, bias=False)
+
+    @staticmethod
+    def masked_mean(hidden_states, attention_mask):
+        if attention_mask is None:
+            return hidden_states.mean(1)
+        lengths = attention_mask.sum(-1)
+        frame_lengths = (lengths * hidden_states.shape[1] / attention_mask.shape[1]).ceil().long()
+        frame_lengths = frame_lengths.clamp(1, hidden_states.shape[1])
+        frame_mask = torch.arange(hidden_states.shape[1], device=hidden_states.device)[None]
+        frame_mask = frame_mask < frame_lengths[:, None]
+        return (hidden_states * frame_mask.unsqueeze(-1)).sum(1) / frame_lengths.unsqueeze(-1)
+
+    def forward(self, input_values, attention_mask=None, return_dict=True, **kwargs):
+        encoded = self.encoder(
+            input_values=input_values,
+            attention_mask=attention_mask,
+            return_dict=True,
+            **kwargs,
+        ).last_hidden_state
+        embedding = self.bottleneck(self.masked_mean(encoded, attention_mask))
+        accent_logits = self.accent_classifier(embedding)
+        speaker_logits = self.speaker_classifier(embedding)
+        if not return_dict:
+            return embedding, accent_logits, speaker_logits
+        return GenAIDOutput(
+            embedding=embedding,
+            accent_logits=accent_logits,
+            speaker_logits=speaker_logits,
+        )

preprocessor_config.json

@@ -0,0 +1,9 @@
+{
+  "do_normalize": true,
+  "feature_extractor_type": "Wav2Vec2FeatureExtractor",
+  "feature_size": 1,
+  "padding_side": "right",
+  "padding_value": 0,
+  "return_attention_mask": true,
+  "sampling_rate": 16000
+}