diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000000000000000000000000000000000..ce59f67cb8890e60f6c698860ff86a54cb0b419d
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,74 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro 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
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds 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
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+data/ossi/Large_12k/perspk1/probe filter=lfs diff=lfs merge=lfs -text
+data/ossi/Large_12k/perspk3/probe filter=lfs diff=lfs merge=lfs -text
+data/ossi/Large_12k/perspk5/all filter=lfs diff=lfs merge=lfs -text
+data/ossi/Large_12k/perspk5/probe filter=lfs diff=lfs merge=lfs -text
+data/ossi/Large_12k/spk2utt filter=lfs diff=lfs merge=lfs -text
+data/ossi/Large_12k/utt2spk filter=lfs diff=lfs merge=lfs -text
+data/ossi/Large_12k/wav.scp filter=lfs diff=lfs merge=lfs -text
+data/spk2videos filter=lfs diff=lfs merge=lfs -text
+progress/download_progress_6_0.json filter=lfs diff=lfs merge=lfs -text
+progress/download_progress_6_4.json filter=lfs diff=lfs merge=lfs -text
+progress/download_progress_6_5.json filter=lfs diff=lfs merge=lfs -text
+progress/download_progress_6_2.json filter=lfs diff=lfs merge=lfs -text
+progress/download_progress_6_3.json filter=lfs diff=lfs merge=lfs -text
+progress/download_progress_6_1.json filter=lfs diff=lfs merge=lfs -text
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..899c7675d310b35cc24c5a63defd227f8fa7269e
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,13 @@
+LICENSE FOR THE VoxBlink DATASET
+
+Description:
+In this paper, we provide a large audio-visual speaker recognition dataset, VoxBlink2, which includes approximately 10M utterances with videos from 110K+ speakers in the wild. This dataset represents a significant expansion over the VoxBlink dataset, encompassing a broader diversity of speakers and scenarios by the grace of an optimized data collection pipeline. Afterward, we explore the impact of training strategies, data scale, and model complexity on speaker verification and finally establish a new single-model state-of-the-art EER at 0.170% and minDCF at 0.006% on the VoxCeleb1-O test set. Such remarkable results motivate us to explore speaker recognition from a new challenging perspective. We raise the Open-Set Speaker-Identification task, which is designed to either match a probe utterance with a known gallery speaker or categorize it as an unknown query. Associated with this task, we design concrete benchmark and evaluation protocols. The data and model resources can be found in http://voxblink2.github.io.
+
+License:
+The data falls under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) license. More details on this license can be viewed at https://creativecommons.org/licenses/by-nc-sa/4.0/.
+
+By downloading or using this dataset, you agree to abide by the terms of the CC BY-NC-SA 4.0 license, including any modifications or redistributions in any form.
+
+Disclaimer:
+THIS DATASET IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8bb38ed70036a5043c7ec81b9d21b1f1904c22f6
--- /dev/null
+++ b/README.md
@@ -0,0 +1,131 @@
+# The VoxBlink2 Dataset
+
+The VoxBlink2 dataset is a Large Scale speaker recognition dataset with 100K+ speakers obtained from YouTube platform. This repository provides guidelines to build the corpus and relative resources to reproduce the results in our article . For more introduction, please see [cite](https://VoxBlink2.github.io). If you find this repository helpful to your research, don't forget to give us star🌟.
+
+## Resource
+Let's start with obtaining the [resource](https://drive.google.com/drive/folders/1lzumPsnl5yEaMP9g2bFbSKINLZ-QRJVP?usp=sharing) files and decompressing tar-files.
+```bash
+tar -zxvf spk_info.tar.gz
+tar -zxvf vb2_meta.tar.gz
+tar -zxvf asr_res.tar.gz
+```
+
+## File structure
+
+
+```
+% The file structure is summarized as follows:
+|---- data
+| |---- ossi # [Folder]evaluation protocols for open-set speaker identification
+| |---- test_vox # [Folder] evaluation protocols for speaker verification
+| |---- spk2videos # [spk,video1,video2,...]
+|---- ckpt #checkpoints for evaluation
+| |---- ecapatdnn # [Folder]
+| |---- resnet34 # [Folder]
+| |---- resnet100 # [Folder]
+| |---- resnet293 # [Folder]
+| |---- face_model # [Folder]
+|---- spk_info # video'tags of speakers：
+| |---- id000000
+| |---- id000001
+| |---- ...
+|---- asr_res # ASR annotations by Whisper：
+| |---- id000000
+| |---- id000001
+| |---- ...
+|---- meta # timestamps for video/audio cropping
+| |---- id000000 # spkid
+| |---- DwgYRqnQZHM #videoid
+| |---- 00000.txt #uttid
+| |---- ...
+| |---- ...
+| |---- ...
+|---- face_id # face_identification modules
+| |---- api.py # corresponding inference functions
+| |---- arcface.py # corresponding model definitions
+| |---- README.md
+| |---- test.py # Test
+|---- ossi # video'tags of speakers：
+| |---- eval.py # recipe for evaluate openset speaker identification
+| |---- utils.py
+| |---- example.npy # eg. Resnet34-based embedding for evaluate OSSI
+|---- audio_cropper.py # extract audio-only segments by timestamps from downloaded audios
+|---- video_cropper.py # extract audio-visual segments by timestamps from downloaded videos
+|---- downloader.py # scripts for download videos
+|---- LICENSE # license
+|---- README.md
+|---- requirement.txt
+
+```
+## Download
+The following procedures show how to construct your VoxBlink2
+### Pre-requisites
+1. Install **ffmpeg**:
+```bash
+sudo apt-get update && sudo apt-get upgrade
+sudo apt-get install ffmpeg
+```
+2. Install Python library:
+```bash
+pip install -r requirements.txt
+```
+
+3. Download videos
+
+We provide two alternatives for you to download video or audio-only segments. We Also leverage multi-thread to facilate download process.
+
+* For Audio-Visual
+```python
+python downloader.py --base_dir ${BASE_DIR} --num_workers 4 --mode video
+```
+* For Audio-Only
+```python
+python downloader.py --base_dir ${BASE_DIR} --num_workers 4 --mode audio
+```
+
+4. Crop Audio/Videos
+* For Audio-Visual
+```python
+python cropper_video.py --save_dir_audio ${SAVE_PATH_AUDIO} --save_dir_video ${SAVE_PATH_VIDEO} --timestamp_path meta --video_root=${BASE_DIR} --num_workers 4
+```
+* For Audio-Only
+```python
+python cropper_audio.py --save_dir ${SAVE_PATH_AUDIO} --timestamp_path meta --audio_root=${BASE_DIR} --num_workers 4
+```
+
+## FID Evaluation
+
+We provide simple scripts of our face identification model, which is adopted in curating VoxBlink2. For more, please look at [fid](https://github.com/VoxBlink2/ScriptsForVoxBlink2/tree/main/face_id).
+
+
+## SV Evaluation
+
+We provide simple scripts for model evaluation of ASV, just execute `run_eval.sh` in `asv` folder. For more, please look at [asv](https://github.com/VoxBlink2/ScriptsForVoxBlink2/tree/main/asv).
+
+## Open-Set Speaker Identification Evaluation
+We provide simple scripts for model evaluation of our proposed task: Open-Set Speaker-Identification(OSSI). just execute `run_eval_ossi.sh` in `ossi` folder. For more, please look at [ossi](https://github.com/VoxBlink2/ScriptsForVoxBlink2/tree/main/ossi).
+
+## License
+
+The dataset is licensed under the **CC BY-NC-SA 4.0** license. This means that you can share and adapt the dataset for non-commercial purposes as long as you provide appropriate attribution and distribute your contributions under the same license. Detailed terms can be found [here](LICENSE).
+
+Important Note: Our released dataset only contains annotation data, including the YouTube links, time stamps and speaker labels. We do not release audio or visual data and it is the user's responsibility to decide whether and how to download the video data and whether their intended purpose with the downloaded data is legal in their country. For YouTube users with concerns regarding their videos' inclusion in our dataset, please contact us via E-mail: yuke.lin@dukekunshan.edu.cn or ming.li369@dukekunshan.edu.cn.
+
+
+
+
+## Citation
+
+Please cite the paper below if you make use of the dataset:
+
+```
+@misc{lin2024voxblink2100kspeakerrecognition,
+ title={VoxBlink2: A 100K+ Speaker Recognition Corpus and the Open-Set Speaker-Identification Benchmark},
+ author={Yuke Lin and Ming Cheng and Fulin Zhang and Yingying Gao and Shilei Zhang and Ming Li},
+ year={2024},
+ eprint={2407.11510},
+ archivePrefix={arXiv},
+ primaryClass={eess.AS},
+ url={https://arxiv.org/abs/2407.11510},
+}
+```
\ No newline at end of file
diff --git a/asv/README.md b/asv/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2b5b90dc8fe303bd41c3b74fe0f8111799b17acd
--- /dev/null
+++ b/asv/README.md
@@ -0,0 +1,44 @@
+## SV Evaluation
+To avoid the complex process of downloading data, we provide some model checkpoints for evaluation and fine-tuning. We train the different models with the VoxBlink2 and then LMFT on the VoxCeleb2. Finally, the performances are evaluated on the Vox1-O test set. For more training details, please refer to our manuscript or contact us via e-mail.
+
+
+
+ |
+ Pretrain |
+ FineTune |
+
+
+ | EER |
+ minDCF |
+ EER |
+ minDCF |
+
+
+ | ECAPA-TDNN |
+ 1.728 |
+ 0.177 |
+ 0.675 |
+ 0.053 |
+
+
+ | ResNet34-GSP |
+ 1.728 |
+ 0.176 |
+ 0.553 |
+ 0.056 |
+
+
+ | ResNet100-GSP |
+ 1.132 |
+ 0.113 |
+ 0.457 |
+ 0.049 |
+
+
+ | ResNet293-SimAM-ASP |
+ 0.707 |
+ 0.075 |
+ 0.228 |
+ 0.013 |
+
+
diff --git a/asv/conf/ecapatdnn.yaml b/asv/conf/ecapatdnn.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ef7498491b8b8621cefefd43a690c31d9477f4a0
--- /dev/null
+++ b/asv/conf/ecapatdnn.yaml
@@ -0,0 +1,14 @@
+n_mels: 80
+featCal: !new:modules.feat.logFbankCal
+ sample_rate: 16000
+ n_fft: 512
+ win_length: 0.025
+ hop_length: 0.01
+ n_mels: !ref
+norm_type: 'std'
+embd_dim: 192
+model: !new:modules.model_spk.ECAPA_TDNN
+ C: 1024
+ featCal: !ref
+ckpt_path: 'ckpt/ecapatdnn/model_pt.pt'
+val_name: 'data/test_vox'
diff --git a/asv/conf/resnet100.yaml b/asv/conf/resnet100.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3b6400e822381aaef7cbafd870b32d657ac0ca99
--- /dev/null
+++ b/asv/conf/resnet100.yaml
@@ -0,0 +1,18 @@
+n_mels: 80
+featCal: !new:modules.feat.logFbankCal
+ sample_rate: 16000
+ n_fft: 512
+ win_length: 0.025
+ hop_length: 0.01
+ n_mels: !ref
+norm_type: 'max'
+embd_dim: 256
+model: !new:modules.model_spk.ResNet100_based
+ in_planes: 64
+ block_type: 'Bottleneck'
+ pooling_layer: 'TSP'
+ embd_dim: !ref
+ acoustic_dim: !ref
+ featCal: !ref
+ckpt_path: 'ckpt/resnet100/model_pt.pt'
+val_name: 'data/test_vox'
diff --git a/asv/conf/resnet293.yaml b/asv/conf/resnet293.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..24aa77c61c12294291f7dd6817c827a8118cb878
--- /dev/null
+++ b/asv/conf/resnet293.yaml
@@ -0,0 +1,18 @@
+n_mels: 80
+featCal: !new:modules.feat.logFbankCal
+ sample_rate: 16000
+ n_fft: 512
+ win_length: 0.025
+ hop_length: 0.01
+ n_mels: !ref
+norm_type: 'max'
+embd_dim: 256
+model: !new:modules.model_spk.ResNet293_based
+ in_planes: 64
+ block_type: 'SimAM'
+ pooling_layer: 'ASP'
+ embd_dim: !ref
+ acoustic_dim: !ref
+ featCal: !ref
+ckpt_path: 'ckpt/resnet293/model_pt.pt'
+val_name: 'data/test_vox'
diff --git a/asv/conf/resnet34.yaml b/asv/conf/resnet34.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..26caab4ec7ef84c8fa4c6f2b9a9639dd847c5513
--- /dev/null
+++ b/asv/conf/resnet34.yaml
@@ -0,0 +1,18 @@
+n_mels: 80
+featCal: !new:modules.feat.logFbankCal
+ sample_rate: 16000
+ n_fft: 512
+ win_length: 0.025
+ hop_length: 0.01
+ n_mels: !ref
+norm_type: 'std'
+embd_dim: 256
+model: !new:modules.model_spk.ResNet34_based
+ in_planes: 64
+ block_type: 'base'
+ pooling_layer: 'GSP'
+ embd_dim: !ref
+ acoustic_dim: !ref
+ featCal: !ref
+ckpt_path: 'ckpt/resnet34/model_ft.pt'
+val_name: 'data/test_vox'
diff --git a/asv/dataset.py b/asv/dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..fdc701cdd93caa0f4071e1fbb11bf222382a5063
--- /dev/null
+++ b/asv/dataset.py
@@ -0,0 +1,30 @@
+from scipy.signal import fftconvolve
+from python_speech_features import sigproc
+from torch.utils.data import Dataset
+import scipy.io.wavfile as sciwav
+import torch, numpy as np
+class WavDataset(Dataset):
+ def __init__(self, wav_scp,norm_type):
+ self.wav_scp = wav_scp
+ self.norm_type = norm_type
+ def __len__(self):
+ return len(self.wav_scp)
+
+ def _load_data(self, filename):
+ sr, signal = sciwav.read(filename, mmap=True)
+ return signal
+ def _norm_speech(self, signal):
+ if np.std(signal) == 0:
+ return signal
+ if self.norm_type == 'std':
+ signal = (signal - np.mean(signal)) / np.std(signal)
+ else:
+ signal = signal / (np.abs(signal).max()+ 1e-4)
+ return signal
+ def __getitem__(self, idx):
+ utt, filename = self.wav_scp[idx]
+ signal = self._load_data(filename)
+ signal = self._norm_speech(signal)
+ signal = sigproc.preemphasis(signal, 0.97)
+ signal = torch.from_numpy(signal.astype('float32'))
+ return signal, utt
diff --git a/asv/eval_ckpt.py b/asv/eval_ckpt.py
new file mode 100644
index 0000000000000000000000000000000000000000..6da9c8f9bc68a71b297776b7d38a5b141f385464
--- /dev/null
+++ b/asv/eval_ckpt.py
@@ -0,0 +1,62 @@
+#! /usr/bin/env python3
+import argparse, numpy as np,os
+import torch, torch.nn as nn
+from spk_veri_metric import SVevaluation
+from torch.utils.data import DataLoader
+from dataset import WavDataset
+from tqdm import tqdm
+from hyperpyyaml import load_hyperpyyaml
+
+parser = argparse.ArgumentParser(description="ASV evaluation")
+parser.add_argument('--yaml_path',required=True, type=str)
+parser.add_argument('--device', default='cpu', type=str)
+parser.add_argument('--num_workers', default=10, type=int)
+parser.add_argument('--output_path', required=False, type=str)
+
+args = parser.parse_args()
+# feature
+with open(args.yaml_path, 'r') as f:
+ yaml_strings = f.read()
+ hparams = load_hyperpyyaml(yaml_strings)
+
+
+val_utt = [line.split()[0] for line in open('%s/wav.scp' % hparams['val_name'])]
+
+# dataset
+val_dataset = WavDataset(
+ [
+ line.split()
+ for line in open(
+ '%s/wav.scp' % hparams['val_name']
+ )
+ ],
+ norm_type=hparams['norm_type']
+)
+val_dataloader = DataLoader(
+ val_dataset,
+ num_workers=args.num_workers,
+ shuffle=False,
+ batch_size=1,
+)
+
+model = hparams['model']
+state_dict = torch.load(hparams['ckpt_path'],map_location=args.device)
+model.load_state_dict({k.replace('module.',''):v for k,v in state_dict.items()},strict=False)
+
+model = model.to(args.device)
+
+model.eval()
+embd_stack = np.zeros([0, hparams['embd_dim']])
+embd_dict = {}
+with torch.no_grad():
+ for j, (feat, utt) in enumerate(tqdm(val_dataloader)):
+ embd = model(feat.to(args.device)).cpu().numpy()
+ embd_dict[utt[0]] = embd
+ embd_stack = np.concatenate((embd_stack,embd))
+if os.path.exists('%s/trials' % hparams['val_name']):
+ eer_cal = SVevaluation('%s/trials' % hparams['val_name'], val_utt,ptar=[0.01])
+ eer_cal.update_embd(embd_stack)
+ eer, cost = eer_cal.eer_cost()
+if args.output_path:
+ np.save(os.path.join(args.output_path,'embd.npy'),embd_dict,allow_pickle=True)
+print(eer,cost)
diff --git a/asv/modules/__init__.py b/asv/modules/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/asv/modules/feat.py b/asv/modules/feat.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bff42fc98fa1b69f3c74f592565e08b03d72077
--- /dev/null
+++ b/asv/modules/feat.py
@@ -0,0 +1,17 @@
+from torchaudio import transforms
+import random
+import torch, torch.nn as nn
+
+class logFbankCal(nn.Module):
+ def __init__(self, sample_rate, n_fft, win_length, hop_length, n_mels):
+ super(logFbankCal, self).__init__()
+ self.fbankCal = transforms.MelSpectrogram(sample_rate=sample_rate,
+ n_fft=n_fft,
+ win_length=int(win_length*sample_rate),
+ hop_length=int(hop_length*sample_rate),
+ n_mels=n_mels)
+ def forward(self, x):
+ out = self.fbankCal(x)
+ out = torch.log(out + 1e-6)
+ out = out - out.mean(axis=2).unsqueeze(dim=2)
+ return out
\ No newline at end of file
diff --git a/asv/modules/front_resnet.py b/asv/modules/front_resnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab5ea2d28a9fd1b99cadbcd48b1016452a992939
--- /dev/null
+++ b/asv/modules/front_resnet.py
@@ -0,0 +1,151 @@
+import torch, torch.nn as nn, torch.nn.functional as F
+import math
+import pdb
+import numpy as np
+from torch.nn import init
+
+class SimAMBasicBlock(nn.Module):
+ expansion = 1
+
+ def __init__(self, ConvLayer, NormLayer, in_planes, planes, stride=1,block_id=1):
+ super(SimAMBasicBlock, self).__init__()
+ self.conv1 = ConvLayer(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+ self.bn1 = NormLayer(planes)
+ self.conv2 = ConvLayer(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
+ self.bn2 = NormLayer(planes)
+ self.relu = nn.ReLU(inplace=True)
+ self.sigmoid = nn.Sigmoid()
+
+ self.downsample = nn.Sequential()
+ if stride != 1 or in_planes != self.expansion*planes:
+ self.downsample = nn.Sequential(
+ ConvLayer(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
+ NormLayer(self.expansion*planes)
+ )
+
+ def forward(self, x):
+ out = self.relu(self.bn1(self.conv1(x)))
+ out = self.bn2(self.conv2(out))
+ out = self.SimAM(out)
+ out += self.downsample(x)
+ out = self.relu(out)
+ return out
+
+ def SimAM(self,X,lambda_p=1e-4):
+ n = X.shape[2] * X.shape[3]-1
+ d = (X-X.mean(dim=[2,3], keepdim=True)).pow(2)
+ v = d.sum(dim=[2,3], keepdim=True)/n
+ E_inv = d / (4*(v+lambda_p)) + 0.5
+ return X * self.sigmoid(E_inv)
+
+class BasicBlock(nn.Module):
+ expansion = 1
+
+ def __init__(self, ConvLayer, NormLayer, in_planes, planes, stride=1,block_id=1):
+ super(BasicBlock, self).__init__()
+ self.conv1 = ConvLayer(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+ self.bn1 = NormLayer(planes)
+ self.conv2 = ConvLayer(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
+ self.bn2 = NormLayer(planes)
+ self.relu = nn.ReLU(inplace=True)
+
+ self.downsample = nn.Sequential()
+ if stride != 1 or in_planes != self.expansion*planes:
+ self.downsample = nn.Sequential(
+ ConvLayer(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
+ NormLayer(self.expansion*planes)
+ )
+
+ def forward(self, x):
+ out = self.relu(self.bn1(self.conv1(x)))
+ out = self.bn2(self.conv2(out))
+ out += self.downsample(x)
+ out = self.relu(out)
+ return out
+
+
+class Bottleneck(nn.Module):
+ expansion = 4
+
+ def __init__(self, ConvLayer, NormLayer, in_planes, planes, stride=1,block_id=1):
+ super(Bottleneck, self).__init__()
+ self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
+ self.bn1 = nn.BatchNorm2d(planes)
+ self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+ stride=stride, padding=1, bias=False)
+ self.bn2 = nn.BatchNorm2d(planes)
+ self.conv3 = nn.Conv2d(planes, self.expansion *
+ planes, kernel_size=1, bias=False)
+ self.bn3 = nn.BatchNorm2d(self.expansion*planes)
+
+ self.shortcut = nn.Sequential()
+ if stride != 1 or in_planes != self.expansion*planes:
+ self.shortcut = nn.Sequential(
+ nn.Conv2d(in_planes, self.expansion*planes,
+ kernel_size=1, stride=stride, bias=False),
+ nn.BatchNorm2d(self.expansion*planes)
+ )
+
+ def forward(self, x):
+ out = F.relu(self.bn1(self.conv1(x)))
+ out = F.relu(self.bn2(self.conv2(out)))
+ out = self.bn3(self.conv3(out))
+ out += self.shortcut(x)
+ out = F.relu(out)
+ return out
+
+class ResNet(nn.Module):
+ def __init__(self, in_planes, block, num_blocks, in_ch=1, feat_dim='2d', **kwargs):
+ super(ResNet, self).__init__()
+ if feat_dim=='1d':
+ self.NormLayer = nn.BatchNorm1d
+ self.ConvLayer = nn.Conv1d
+ elif feat_dim=='2d':
+ self.NormLayer = nn.BatchNorm2d
+ self.ConvLayer = nn.Conv2d
+ elif feat_dim=='3d':
+ self.NormLayer = nn.BatchNorm3d
+ self.ConvLayer = nn.Conv3d
+ else:
+ print('error')
+
+ self.in_planes = in_planes
+
+ self.conv1 = self.ConvLayer(in_ch, in_planes, kernel_size=3, stride=1, padding=1, bias=False)
+ self.bn1 = self.NormLayer(in_planes)
+ self.relu = nn.ReLU(inplace=True)
+ self.layer1 = self._make_layer(block, in_planes, num_blocks[0], stride=1,block_id=1)
+ self.layer2 = self._make_layer(block, in_planes*2, num_blocks[1], stride=2,block_id=2)
+ self.layer3 = self._make_layer(block, in_planes*4, num_blocks[2], stride=2,block_id=3)
+ self.layer4 = self._make_layer(block, in_planes*8, num_blocks[3], stride=2,block_id=4)
+
+ def _make_layer(self, block, planes, num_blocks, stride,block_id=1):
+ strides = [stride] + [1]*(num_blocks-1)
+ layers = []
+ for stride in strides:
+ layers.append(block(self.ConvLayer, self.NormLayer, self.in_planes, planes, stride,block_id))
+ self.in_planes = planes * block.expansion
+ return nn.Sequential(*layers)
+
+ def forward(self, x):
+ x = self.relu(self.bn1(self.conv1(x)))
+ x = self.layer1(x)
+ x = self.layer2(x)
+ x = self.layer3(x)
+ x = self.layer4(x)
+ return x
+
+block2module={
+ 'base':BasicBlock,
+ 'SimAM':SimAMBasicBlock,
+ 'Bottleneck':Bottleneck
+ }
+
+def ResNet34(in_planes, block_type, **kwargs):
+ return ResNet(in_planes, block2module[block_type], [3,4,6,3], **kwargs)
+
+def ResNet100(in_planes, block_type, **kwargs):
+ return ResNet(in_planes, block2module[block_type], [6,16,24,3], **kwargs)
+
+def ResNet293(in_planes, block_type, **kwargs):
+ return ResNet(in_planes, block2module[block_type], [10,20,64,3], **kwargs)
diff --git a/asv/modules/model_spk.py b/asv/modules/model_spk.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5e69a93205cfa4ea265ba62c54ce015fec3ef82
--- /dev/null
+++ b/asv/modules/model_spk.py
@@ -0,0 +1,217 @@
+import torch, torch.nn as nn, numpy as np,sys
+from modules.front_resnet import ResNet34, ResNet100,ResNet293,block2module
+import modules.pooling as pooling_func
+import torch.nn.functional as F
+import profile
+####################################################################
+##### ResNet-Based #######################################
+####################################################################
+
+class ResNet34_based(nn.Module):
+ def __init__(self, in_planes, block_type, pooling_layer, embd_dim, acoustic_dim, featCal, dropout=0,**kwargs):
+ super(ResNet34_based, self).__init__()
+ print('ResNet34 based model with %s block and %s pooling' %(block_type, pooling_layer))
+ self.featCal = featCal
+ self.front = ResNet34(in_planes, block_type)
+ self.pooling = getattr(pooling_func, pooling_layer)(in_planes,acoustic_dim)
+ self.bottleneck = nn.Linear(self.pooling.out_dim, embd_dim)
+ self.drop = nn.Dropout(dropout) if dropout else None
+ def forward(self, x):
+ x = self.featCal(x)
+ x = self.front(x.unsqueeze(dim=1))
+ x = self.pooling(x)
+ if self.drop:
+ x = self.drop(x)
+ x = self.bottleneck(x)
+ return x
+
+
+class ResNet100_based(nn.Module):
+ def __init__(self, in_planes, block_type, pooling_layer, embd_dim, acoustic_dim, featCal, dropout=0, **kwargs):
+ super(ResNet100_based, self).__init__()
+ print('ResNet100 based model with %s and %s ' %(block_type, pooling_layer))
+ self.featCal = featCal
+ self.front = ResNet100(in_planes, block_type)
+ block_expansion = block2module[block_type].expansion
+ self.pooling = getattr(pooling_func, pooling_layer)(in_planes*block_expansion,acoustic_dim)
+ self.bottleneck = nn.Linear(self.pooling.out_dim, embd_dim)
+ self.drop = nn.Dropout(dropout) if dropout else None
+
+ def forward(self, x):
+ x = self.featCal(x)
+ x = self.front(x.unsqueeze(dim=1))
+ x = self.pooling(x)
+ if self.drop:
+ x = self.drop(x)
+ x = self.bottleneck(x)
+
+ return x
+
+class ResNet293_based(nn.Module):
+ def __init__(self, in_planes, block_type, pooling_layer, embd_dim, acoustic_dim, featCal, dropout=0,**kwargs):
+ super(ResNet293_based, self).__init__()
+ print('ResNet293 based model with %s and %s ' %(block_type, pooling_layer))
+ self.featCal = featCal
+ self.front = ResNet293(in_planes, block_type)
+ block_expansion = block2module[block_type].expansion
+ self.pooling = getattr(pooling_func, pooling_layer)(in_planes*block_expansion,acoustic_dim)
+ self.bottleneck = nn.Linear(self.pooling.out_dim, embd_dim)
+ self.drop = nn.Dropout(dropout) if dropout else None
+
+ def forward(self, x):
+ x = self.featCal(x)
+ x = self.front(x.unsqueeze(dim=1))
+ x = self.pooling(x)
+ if self.drop:
+ x = self.drop(x)
+ x = self.bottleneck(x)
+ return x
+
+####################################################################
+##### ECAPA_TDNN #######################################
+####################################################################
+
+import torch
+from torch import nn
+from torch.nn import Parameter
+import torch.nn.functional as F
+
+####################################################################
+##### ECAPA_TDNN #######################################
+####################################################################
+
+import math, torch, torchaudio
+import torch.nn as nn
+import torch.nn.functional as F
+from thop import profile
+
+class SEModule(nn.Module):
+ def __init__(self, channels, bottleneck=128):
+ super(SEModule, self).__init__()
+ self.se = nn.Sequential(
+ nn.AdaptiveAvgPool1d(1),
+ nn.Conv1d(channels, bottleneck, kernel_size=1, padding=0),
+ nn.ReLU(),
+ # nn.BatchNorm1d(bottleneck), # I remove this layer
+ nn.Conv1d(bottleneck, channels, kernel_size=1, padding=0),
+ nn.Sigmoid(),
+ )
+
+ def forward(self, input):
+ x = self.se(input)
+ return input * x
+
+class Bottle2neck(nn.Module):
+
+ def __init__(self, inplanes, planes, kernel_size=None, dilation=None, scale = 8):
+ super(Bottle2neck, self).__init__()
+ width = int(math.floor(planes / scale))
+ self.conv1 = nn.Conv1d(inplanes, width*scale, kernel_size=1)
+ self.bn1 = nn.BatchNorm1d(width*scale)
+ self.nums = scale -1
+ convs = []
+ bns = []
+ num_pad = math.floor(kernel_size/2)*dilation
+ for i in range(self.nums):
+ convs.append(nn.Conv1d(width, width, kernel_size=kernel_size, dilation=dilation, padding=num_pad))
+ bns.append(nn.BatchNorm1d(width))
+ self.convs = nn.ModuleList(convs)
+ self.bns = nn.ModuleList(bns)
+ self.conv3 = nn.Conv1d(width*scale, planes, kernel_size=1)
+ self.bn3 = nn.BatchNorm1d(planes)
+ self.relu = nn.ReLU()
+ self.width = width
+ self.se = SEModule(planes)
+
+ def forward(self, x):
+ residual = x
+ out = self.conv1(x)
+ out = self.relu(out)
+ out = self.bn1(out)
+
+ spx = torch.split(out, self.width, 1)
+ for i in range(self.nums):
+ if i==0:
+ sp = spx[i]
+ else:
+ sp = sp + spx[i]
+ sp = self.convs[i](sp)
+ sp = self.relu(sp)
+ sp = self.bns[i](sp)
+ if i==0:
+ out = sp
+ else:
+ out = torch.cat((out, sp), 1)
+ out = torch.cat((out, spx[self.nums]),1)
+
+ out = self.conv3(out)
+ out = self.relu(out)
+ out = self.bn3(out)
+
+ out = self.se(out)
+ out += residual
+ return out
+
+
+class ECAPA_TDNN(nn.Module):
+
+ def __init__(self, C, featCal):
+
+ super(ECAPA_TDNN, self).__init__()
+ self.featCal = featCal
+ self.conv1 = nn.Conv1d(80, C, kernel_size=5, stride=1, padding=2)
+ self.relu = nn.ReLU()
+ self.bn1 = nn.BatchNorm1d(C)
+ self.layer1 = Bottle2neck(C, C, kernel_size=3, dilation=2, scale=8)
+ self.layer2 = Bottle2neck(C, C, kernel_size=3, dilation=3, scale=8)
+ self.layer3 = Bottle2neck(C, C, kernel_size=3, dilation=4, scale=8)
+ # I fixed the shape of the output from MFA layer, that is close to the setting from ECAPA paper.
+ self.layer4 = nn.Conv1d(3*C, 1536, kernel_size=1)
+ self.attention = nn.Sequential(
+ nn.Conv1d(4608, 256, kernel_size=1),
+ nn.ReLU(),
+ nn.BatchNorm1d(256),
+ nn.Tanh(), # I add this layer
+ nn.Conv1d(256, 1536, kernel_size=1),
+ nn.Softmax(dim=2),
+ )
+ self.bn5 = nn.BatchNorm1d(3072)
+ self.fc6 = nn.Linear(3072, 192)
+ self.bn6 = nn.BatchNorm1d(192)
+
+
+ def forward(self, x):
+ x = self.featCal(x)
+ x = self.conv1(x)
+ x = self.relu(x)
+ x = self.bn1(x)
+
+ x1 = self.layer1(x)
+ x2 = self.layer2(x+x1)
+ x3 = self.layer3(x+x1+x2)
+
+ x = self.layer4(torch.cat((x1,x2,x3),dim=1))
+ x = self.relu(x)
+
+ t = x.size()[-1]
+
+ global_x = torch.cat((x,torch.mean(x,dim=2,keepdim=True).repeat(1,1,t), torch.sqrt(torch.var(x,dim=2,keepdim=True).clamp(min=1e-4)).repeat(1,1,t)), dim=1)
+
+ w = self.attention(global_x)
+
+ mu = torch.sum(x * w, dim=2)
+ sg = torch.sqrt( ( torch.sum((x**2) * w, dim=2) - mu**2 ).clamp(min=1e-4) )
+
+ x = torch.cat((mu,sg),1)
+ x = self.bn5(x)
+ x = self.fc6(x)
+ x = self.bn6(x)
+
+ return x
+
+if __name__ == '__main__':
+ model = ResNet34_based(64,'base',pooling_layer='GSP',embd_dim=256,acoustic_dim=80)
+ input = torch.rand([1, 16000])
+ flops, params = profile(model, inputs=(input, ))
+ print('FLOPs = ' + str(flops/1024**3) + 'G')
+ print('Params = ' + str(params/1024**2) + 'M')
diff --git a/asv/modules/pooling.py b/asv/modules/pooling.py
new file mode 100644
index 0000000000000000000000000000000000000000..88bc48f950a8ed8a3a555864dfcd71e8f0b07bd7
--- /dev/null
+++ b/asv/modules/pooling.py
@@ -0,0 +1,52 @@
+import torch, torch.nn as nn, torch.nn.functional as F
+
+class GSP(nn.Module):
+ # GlobalStatsPool
+ def __init__(self,in_planes,acoustic_dim):
+ super(GSP, self).__init__()
+ self.out_dim = in_planes*8 * 2
+
+ def forward(self, x):
+ x = x.view(x.shape[0], x.shape[1], -1)
+ out = torch.cat([x.mean(dim=2), x.std(dim=2)], dim=1)
+ return out
+
+class ASP(nn.Module):
+ # Attentive statistics pooling
+ def __init__(self,in_planes,acoustic_dim):
+ super(ASP, self).__init__()
+ outmap_size = int(acoustic_dim/8)
+ self.out_dim = in_planes*8 * outmap_size * 2
+
+ self.attention = nn.Sequential(
+ nn.Conv1d(in_planes*8 * outmap_size, 128, kernel_size=1),
+ nn.ReLU(),
+ nn.BatchNorm1d(128),
+ nn.Conv1d(128, in_planes*8 * outmap_size, kernel_size=1),
+ nn.Softmax(dim=2),
+ )
+
+ def forward(self, x):
+ x = x.reshape(x.size()[0],-1,x.size()[-1])
+ w = self.attention(x)
+ mu = torch.sum(x * w, dim=2)
+ sg = torch.sqrt( ( torch.sum((x**2) * w, dim=2) - mu**2 ).clamp(min=1e-5) )
+ x = torch.cat((mu,sg),1)
+
+ x = x.view(x.size()[0], -1)
+ return x
+
+class TSP(nn.Module):
+ # TemporalStatsPool
+ def __init__(self,in_planes,acoustic_dim):
+ super(TSP, self).__init__()
+ outmap_size = int(acoustic_dim/8)
+ self.out_dim = in_planes * 8 * outmap_size * 2
+ def forward(self, x):
+ out_mean = x.mean(dim=-1)
+ out_std = torch.sqrt(torch.var(x, dim=-1) + 1e-7)
+ out_mean = out_mean.flatten(start_dim=1)
+ out_std = out_std.flatten(start_dim=1)
+ out = torch.cat((out_mean, out_std), 1)
+ return out
+
\ No newline at end of file
diff --git a/asv/run_eval.sh b/asv/run_eval.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0b32079c0dfc6631b5d003ee9d7fceb6aa5cd372
--- /dev/null
+++ b/asv/run_eval.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+if command -v nvidia-smi &> /dev/null && nvidia-smi -L &> /dev/null; then
+ device="cuda"
+else
+ device="cpu"
+fi
+num_workers=4
+yaml_conf=asv/conf/resnet34.yaml
+python asv/eval_ckpt.py --num_workers=${num_workers} --device=${device} --yaml_path=${yaml_conf}
\ No newline at end of file
diff --git a/asv/spk_veri_metric.py b/asv/spk_veri_metric.py
new file mode 100644
index 0000000000000000000000000000000000000000..0754b23ea22e4f13bbd1ed29d895d637913bc3e5
--- /dev/null
+++ b/asv/spk_veri_metric.py
@@ -0,0 +1,97 @@
+import numpy as np
+
+
+def length_norm(mat):
+ return mat / np.sqrt(np.sum(mat * mat, axis=1))[:, None]
+
+
+def compute_pmiss_pfa_rbst(scores, labels, weights=None):
+ """ computes false positive rate (FPR) and false negative rate (FNR)
+ given trial socres and their labels. A weights option is also provided
+ to equalize the counts over score partitions (if there is such
+ partitioning).
+ """
+
+ sorted_ndx = np.argsort(scores)
+ labels = labels[sorted_ndx]
+ if weights is not None:
+ weights = weights[sorted_ndx]
+ else:
+ weights = np.ones((labels.shape), dtype='f8')
+
+ tgt_wghts = weights * (labels == 1).astype('f8')
+ imp_wghts = weights * (labels == 0).astype('f8')
+
+ fnr = np.cumsum(tgt_wghts) / np.sum(tgt_wghts)
+ fpr = 1 - np.cumsum(imp_wghts) / np.sum(imp_wghts)
+ return fnr, fpr
+
+
+def compute_eer(fnr, fpr):
+ """ computes the equal error rate (EER) given FNR and FPR values calculated
+ for a range of operating points on the DET curve
+ """
+
+ diff_pm_fa = fnr - fpr
+ x1 = np.flatnonzero(diff_pm_fa >= 0)[0]
+ x2 = np.flatnonzero(diff_pm_fa <