File size: 2,833 Bytes
015eab9 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
---
base_model:
- gru-audio-binary
datasets:
- mozilla-foundation/common_voice_11_0
language:
- zh
metrics:
- accuracy
pipeline_tag: audio-classification
tags:
- speaker_dialect_classification
library_name: transformers
---
# shanghai-binary
Binary classifier: **Shanghai** vs **Not-Shanghai** (audio FBANK → GRU → MLP).
## Files
- `model.safetensors` — PyTorch weights (safetensors)
- `config.json` — model architecture
- `preprocessor_config.json` — audio feature extraction settings
- `label_mapping.json` — index → label
## Inference (PyTorch)
```python
import torch, json, numpy as np, librosa
from safetensors.torch import load_file as load_safetensors
# Load config
import json, os
model_dir = "./hf/models/shanghai-binary"
cfg = json.load(open(os.path.join(model_dir, "config.json")))
pp = json.load(open(os.path.join(model_dir, "preprocessor_config.json")))
lm = json.load(open(os.path.join(model_dir, "label_mapping.json")))
# Define the model class you trained (LanNetBinary)
# (Same as in your training notebook)
class LanNetBinary(torch.nn.Module):
def __init__(self, input_dim=40, hidden_dim=512, num_layers=2):
super().__init__()
self.gru = torch.nn.GRU(input_dim, hidden_dim, num_layers=num_layers, batch_first=True)
self.linear2 = torch.nn.Linear(hidden_dim, 192)
self.linear3 = torch.nn.Linear(192, 2)
def forward(self, x):
out, _ = self.gru(x)
last = out[:, -1, :]
x = self.linear2(last)
x = self.linear3(x)
return x
# Load weights
model = LanNetBinary(cfg["input_dim"], cfg["hidden_dim"], cfg["num_layers"])
sd = load_safetensors(os.path.join(model_dir, "model.safetensors"))
model.load_state_dict(sd, strict=True)
model.eval()
# Feature extraction should match preprocessor_config.json
def fbanks_from_array(y, sr=pp["sampling_rate"], n_mels=pp["n_mels"], n_fft=pp["n_fft"], hop_length=pp["hop_length"], max_len=pp["max_len_frames"]):
mel = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=n_mels, n_fft=n_fft, hop_length=hop_length, power=2.0)
fbanks = librosa.power_to_db(mel).T
T = fbanks.shape[0]
if T < max_len:
import numpy as np
fbanks = np.pad(fbanks, ((0, max_len - T), (0, 0)), mode="constant")
else:
fbanks = fbanks[:max_len, :]
return torch.tensor(fbanks, dtype=torch.float32).unsqueeze(0) # (1, T, F)
# Example: predict from a waveform array "y" at 16kHz
# y, _ = librosa.load("example.wav", sr=pp["sampling_rate"])
# x = fbanks_from_array(y)
# with torch.no_grad():
# logits = model(x)
# pred = int(torch.argmax(logits, dim=1))
# print(lm[str(pred)])
```
## References
- Model based from [https://github.com/Colt1990/chinese-dialect-recognition/tree/master](https://github.com/Colt1990/chinese-dialect-recognition/tree/master)
|