init

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/experiment-speaker-embedding.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.9 (distil) (8)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,15 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="2">
+            <item index="0" class="java.lang.String" itemvalue="pandas" />
+            <item index="1" class="java.lang.String" itemvalue="requests" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.9 (distil) (8)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (distil) (8)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/experiment-speaker-embedding.iml" filepath="$PROJECT_DIR$/.idea/experiment-speaker-embedding.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

model_meta_voice.py

@@ -0,0 +1,104 @@
+"""Speaker embedding obtained via speaker verification training.
+- feature dimension: 256
+- source: https://github.com/metavoiceio/metavoice-src
+"""
+import os
+import subprocess
+from os.path import join as p_join
+from typing import Optional
+
+import librosa
+from librosa import feature
+import numpy as np
+import torch
+from torch import nn
+
+
+checkpoint_url = "https://huggingface.co/datasets/asahi417/experiment-speaker-embedding/resolve/main/speaker_encoder.pt"
+model_weight = p_join(os.path.expanduser('~'), ".cache", "experiment_speaker_embedding", "speaker_encoder.pt")
+
+
+def wget(url: str, output_file: Optional[str] = None):
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    subprocess.run(["wget", url, "-O", output_file])
+    if not os.path.exists(output_file):
+        raise ValueError(f"failed to download {url}")
+
+
+class MetaVoiceSE(nn.Module):
+
+    mel_window_length = 25
+    mel_window_step = 10
+    mel_n_channels = 40
+    sampling_rate = 16000
+    partials_n_frames = 160
+    model_hidden_size = 256
+    model_embedding_size = 256
+    model_num_layers = 3
+
+    def __init__(self):
+        super().__init__()
+        if not os.path.exists(model_weight):
+            wget(checkpoint_url, model_weight)
+        # Define the network
+        self.lstm = nn.LSTM(self.mel_n_channels, self.model_hidden_size, self.model_num_layers, batch_first=True)
+        self.linear = nn.Linear(self.model_hidden_size, self.model_embedding_size)
+        self.relu = nn.ReLU()
+        # Load weight
+        self.load_state_dict(torch.load(model_weight, map_location="cpu")["model_state"], strict=False)
+        # Get the target device
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.to(self.device)
+        self.eval()
+
+    def compute_partial_slices(self, n_samples: int, rate, min_coverage):
+        # Compute how many frames separate two partial utterances
+        samples_per_frame = int((self.sampling_rate * self.mel_window_step / 1000))
+        n_frames = int(np.ceil((n_samples + 1) / samples_per_frame))
+        frame_step = int(np.round((self.sampling_rate / rate) / samples_per_frame))
+        # Compute the slices
+        wav_slices, mel_slices = [], []
+        steps = max(1, n_frames - self.partials_n_frames + frame_step + 1)
+        for i in range(0, steps, frame_step):
+            mel_range = np.array([i, i + self.partials_n_frames])
+            wav_range = mel_range * samples_per_frame
+            mel_slices.append(slice(*mel_range))
+            wav_slices.append(slice(*wav_range))
+        # Evaluate whether extra padding is warranted or not
+        last_wav_range = wav_slices[-1]
+        coverage = (n_samples - last_wav_range.start) / (last_wav_range.stop - last_wav_range.start)
+        if coverage < min_coverage and len(mel_slices) > 1:
+            return wav_slices[:-1], mel_slices[:-1]
+        return wav_slices, mel_slices
+
+    def get_speaker_embedding(self,
+                              wav: np.ndarray,
+                              sampling_rate: Optional[int] = None,
+                              rate: float = 1.3,
+                              min_coverage: float = 0.75) -> np.ndarray:
+        if sampling_rate != self.sampling_rate:
+            wav = librosa.resample(wav, orig_sr=sampling_rate, target_sr=self.sampling_rate)
+        wav, _ = librosa.effects.trim(wav, top_db=20)
+        wav_slices, mel_slices = self.compute_partial_slices(len(wav), rate, min_coverage)
+        max_wave_length = wav_slices[-1].stop
+        if max_wave_length >= len(wav):
+            wav = np.pad(wav, (0, max_wave_length - len(wav)), "constant")
+        # Wav -> Mel spectrogram
+        frames = feature.melspectrogram(
+            y=wav,
+            sr=self.sampling_rate,
+            n_fft=int(self.sampling_rate * self.mel_window_length / 1000),
+            hop_length=int(self.sampling_rate * self.mel_window_step / 1000),
+            n_mels=self.mel_n_channels,
+        )
+        mel = frames.astype(np.float32).T
+        mel = np.array([mel[s] for s in mel_slices])
+        # inference
+        with torch.no_grad():
+            mel = torch.from_numpy(mel).to(self.device)
+            _, (hidden, _) = self.lstm(mel)
+            embeds_raw = self.relu(self.linear(hidden[-1]))
+            partial_embeds = embeds_raw / torch.norm(embeds_raw, dim=1, keepdim=True)
+        partial_embeds = partial_embeds.cpu().numpy()
+        raw_embed = np.mean(partial_embeds, axis=0)
+        return raw_embed / np.linalg.norm(raw_embed, 2)

model_pyannote_embedding.py

@@ -0,0 +1,33 @@
+"""Pyannote speaker embedding model.
+- pip install pyannote.audio
+- feature dimension: 512
+- source: https://huggingface.co/pyannote/embedding
+"""
+from typing import Optional, Union, Tuple
+import torch
+import numpy as np
+from pyannote.audio import Model
+from pyannote.audio import Inference
+from pyannote.audio.core.inference import fix_reproducibility, map_with_specifications
+
+
+class PyannoteSE:
+
+    def __init__(self):
+        self.model = Model.from_pretrained("pyannote/embedding")
+        self.inference = Inference(self.model, window="whole")
+
+    def get_speaker_embedding(self, wav: np.ndarray, sampling_rate: Optional[int] = None) -> np.ndarray:
+        wav = torch.as_tensor(wav.reshape(1, -1))
+        fix_reproducibility(self.inference.device)
+        if self.inference.window == "sliding":
+            return self.inference.slide(wav, sampling_rate, hook=None)
+
+        outputs: Union[np.ndarray, Tuple[np.ndarray]] = self.inference.infer(wav[None])
+
+        def __first_sample(outputs: np.ndarray, **kwargs) -> np.ndarray:
+            return outputs[0]
+
+        return map_with_specifications(
+            self.model.specifications, __first_sample, outputs
+        )

model_w2v_bert.py

@@ -0,0 +1,28 @@
+"""Meta's w2vBERT based speaker embedding.
+- feature dimension: 1024
+- source: https://huggingface.co/facebook/w2v-bert-2.0
+"""
+from typing import Optional
+
+import torch
+import librosa
+import numpy as np
+from transformers import Wav2Vec2BertModel, AutoFeatureExtractor
+
+
+class W2VBertSE:
+    def __init__(self):
+        self.processor = AutoFeatureExtractor.from_pretrained("facebook/w2v-bert-2.0")
+        self.model = Wav2Vec2BertModel.from_pretrained("facebook/w2v-bert-2.0")
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model.to(self.device)
+        self.model.eval()
+
+    def get_speaker_embedding(self, wav: np.ndarray, sampling_rate: Optional[int] = None) -> np.ndarray:
+        # audio file is decoded on the fly
+        if sampling_rate != self.processor.sampling_rate:
+            wav = librosa.resample(wav, orig_sr=sampling_rate, target_sr=self.processor.sampling_rate)
+        inputs = self.processor(wav, sampling_rate=self.processor.sampling_rate, return_tensors="pt")
+        with torch.no_grad():
+            outputs = self.model(**{k: v.to(self.device) for k, v in inputs.items()})
+        return outputs.last_hidden_state.mean(1).cpu().numpy()[0]

sample.wav

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

test.py

@@ -0,0 +1,24 @@
+import librosa
+from model_meta_voice import MetaVoiceSE
+from model_pyannote_embedding import PyannoteSE
+from model_w2v_bert import W2VBertSE
+
+
+def test():
+    wav, sr = librosa.load("sample.wav")
+    print("MetaVoiceSE")
+    model = MetaVoiceSE()
+    v = model.get_speaker_embedding(wav, sr)
+    print(v.shape)
+    print("PyannoteSE")
+    model = PyannoteSE()
+    v = model.get_speaker_embedding(wav, sr)
+    print(v.shape)
+    print("W2VBertSE")
+    model = W2VBertSE()
+    v = model.get_speaker_embedding(wav, sr)
+    print(v.shape)
+
+
+if __name__ == '__main__':
+    test()