upload all

.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

cache/embs_cache/e609b16c50d879c.pkl

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

download_audios.py

@@ -0,0 +1,16 @@
+import tarfile
+import glob
+import os
+from huggingface_hub import hf_hub_download
+
+
+def download_audios():
+    wav_files = sorted(glob.glob(os.path.join("audios", '*.wav')))
+    if len(wav_files) == 0:
+        audios_targz_path = hf_hub_download(repo_id="omniway/Audio_speaker_needle_in_haystack", filename="audios.tar.gz", repo_type="dataset")
+        tar = tarfile.open(audios_targz_path, 'r:gz')
+        tar.extractall(path='.')
+        tar.close()
+
+if __name__ == '__main__':
+    download_audios()

packages.txt

@@ -0,0 +1,2 @@
+ffmpeg
+libsox-dev

requirements.txt

@@ -0,0 +1,7 @@
+modelscope==1.15.0
+torch==2.3.1
+torchaudio==2.3.1
+torchvision==0.18.1
+tqdm
+librosa
+soundfile

webui_speaker_needle_in_haystack.py

@@ -0,0 +1,275 @@
+import os
+import operator
+import glob
+import librosa
+import argparse
+import hashlib
+import gradio as gr
+import numpy as np
+import pickle
+
+from tqdm import tqdm
+from modelscope.pipelines import pipeline
+from download_audios import download_audios
+
+"""
+
+Audio Speaker needle in haystack
+cronrpc
+https://github.com/cronrpc
+
+"""
+
+MAX_DISPLAY_AUDIO_NUMBER = 10
+g_gr_audio_list = []
+
+
+class Speaker_Needle_In_Haystack():
+    SAMPLE_RATE = 16000 
+
+    def __init__(self, pickle_support = False) -> None:
+        self._load_model()
+        self.all_embs = {}
+        self.cosine_score = {}
+        self.pickle_support = pickle_support
+        pass
+
+    def set_audio_list_dir(self, dir_path):
+        self.audio_list_dir = dir_path
+
+    def _load_model(self) -> None:
+        # could switch model here 
+
+        self.model_name = 'damo/speech_eres2netv2_sv_zh-cn_16k-common'
+        self.sv_pipline = pipeline(
+            task='speaker-verification',
+            model=self.model_name,
+            model_revision='v1.0.1'
+        )
+
+        # self.model_name = 'iic/speech_campplus_sv_zh-cn_3dspeaker_16k'
+        # self.sv_pipline = pipeline(
+        #     task='speaker-verification',
+        #     model=self.model_name
+        # )
+
+    def _get_emb(self, audio) -> None:
+        if isinstance(audio, str):
+            audio, sr = librosa.load(audio, sr=self.SAMPLE_RATE, mono=True)
+            return self.sv_pipline([audio], output_emb=True)['embs'] # (1,196) np array
+        elif isinstance(audio, list):
+            return self.sv_pipline(audio, output_emb=True)['embs'] # (n,196) np array
+        else:
+            return self.sv_pipline([audio], output_emb=True)['embs'] # (1,196) np array
+
+    def _cosine_similarity_compute(self, emb1, emb2):
+        emb1 = np.squeeze(emb1)
+        emb2 = np.squeeze(emb2)
+        dot_product = np.dot(emb1, emb2)
+        norm_vector1 = np.linalg.norm(emb1)
+        norm_vector2 = np.linalg.norm(emb2)
+        cosine_similarity = dot_product / (norm_vector1 * norm_vector2)
+        return cosine_similarity
+
+    def compute_all_embs(self, batch_size=1):
+        wav_files = sorted(glob.glob(os.path.join(self.audio_list_dir, '*.wav')))
+
+        # hash to skip
+        file_string = self.model_name + ''.join(wav_files)
+        hash_file = hashlib.sha256(file_string.encode()).hexdigest()[:15] + ".pkl"
+        if self.pickle_support:
+            cache_dir = os.path.join('cache','embs_cache')
+            os.makedirs(cache_dir, exist_ok=True)
+            hash_file = os.path.join(cache_dir, hash_file)
+            if os.path.exists(hash_file):
+                print("load pickle embs")
+                self.load_all_embs(hash_file)
+                return
+
+        self.all_embs = {}
+        num_files = len(wav_files)
+        num_batches = (num_files + batch_size - 1) // batch_size
+
+        for batch_idx in tqdm(range(num_batches)):
+            start_idx = batch_idx * batch_size
+            end_idx = min((batch_idx + 1) * batch_size, num_files)
+            batch_files = wav_files[start_idx:end_idx]
+            batch_audio = []
+
+            for file_path in batch_files:
+                audio, sr = librosa.load(file_path, sr=self.SAMPLE_RATE, mono=True)
+                batch_audio.append(audio)
+
+            embs = self._get_emb(batch_audio)
+
+            for i, file_path in enumerate(batch_files):
+                self.all_embs[file_path] = embs[i]
+
+        # save the self.all_embs in hash_value named file
+        if self.pickle_support:
+            self.save_all_embs(hash_file)
+
+    def compute_target_aduio_cosine_score(self, target_audio):
+        self.cosine_score = {}
+        target_emb = self._get_emb(target_audio)
+        for file_path, emb in self.all_embs.items():
+            self.cosine_score[file_path] = self._cosine_similarity_compute(target_emb, emb)
+
+    def get_cosine_next_top_k(self, k, start = 0):
+        top_subset = sorted(self.cosine_score.items(), key=operator.itemgetter(1), reverse=True)[start: start + k]
+        return top_subset
+    
+    def save_all_embs(self, hash_file):
+        file_path = hash_file
+        with open(file_path, 'wb') as file:
+            pickle.dump(self.all_embs, file)
+
+    def load_all_embs(self, hash_file):
+        file_path = hash_file
+        with open(file_path, 'rb') as file:
+            self.all_embs = pickle.load(file)
+
+
+def get_similar_score_audio(audio, start_index):
+    output = []
+    top_subset = []
+    
+    if audio != None:
+        sr, y = audio
+        if len(y.shape) == 2:
+            y = np.mean(y, axis=-1)
+        audio_16k = librosa.resample(y.astype(np.float32), orig_sr=sr, target_sr=snih.SAMPLE_RATE)
+        snih.compute_target_aduio_cosine_score(audio_16k)
+        top_subset = snih.get_cosine_next_top_k(MAX_DISPLAY_AUDIO_NUMBER, start=start_index)
+
+    for i in range(0, len(top_subset)):
+        path, score = top_subset[i]
+        file_name = os.path.basename(path)
+        output.append(
+            {
+                "__type__":"update",
+                "value":path,
+                "label":f"{start_index+i}:{file_name} score={score:.4f}"
+            }
+        )
+
+    for _ in range(0, MAX_DISPLAY_AUDIO_NUMBER - len(top_subset)):
+        output.append(
+            {
+                "__type__":"update",
+                "value":None,
+                "label":"None"
+            }
+        )
+
+    return *output, start_index
+
+
+def get_next_index_zero(audio):
+    return get_similar_score_audio(audio, 0)
+
+
+def get_next_index(audio, start_index):
+    return get_similar_score_audio(audio, start_index + 10)
+
+
+def get_previous_index(audio, start_index):
+    return get_similar_score_audio(audio, max(start_index - 10, 0))
+
+
+if __name__ == '__main__':
+
+    download_audios()
+    
+    parser = argparse.ArgumentParser(description='Speaker_Needle_In_Haystack demo Launch')
+    parser.add_argument('--server_name', type=str, default='0.0.0.0', help='Server name')
+    parser.add_argument('--server_port', type=int, default=8080, help='Server port')
+    parser.add_argument('--batch_size', type=int, default=4, help='the batch_size about embedding generate')
+    parser.add_argument('--audio_dir', type=str, default="audios", help='the audio dir which will be compared to target audio')
+    parser.add_argument('--disable_pickle_support', action='store_true', help="save emb by pickle")
+    args = parser.parse_args()
+
+    pickle_support = not args.disable_pickle_support
+    print("pickle support : ", pickle_support)
+    snih = Speaker_Needle_In_Haystack(pickle_support=pickle_support)
+
+    snih.set_audio_list_dir(args.audio_dir)
+    snih.compute_all_embs(batch_size = args.batch_size)
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# 大海捞针 Audio Needle In Haystack")
+        with gr.Row():
+            audio_input = gr.Audio(
+                    label= "Input Audio / 输入音频",
+                    visible = True,
+                    scale=5,
+                    type="numpy",
+                    format='wav'
+                )
+            
+            with gr.Column():
+                wav_files = sorted(glob.glob(os.path.join("examples", '*.wav')))
+                gr.Examples(
+                    examples=[
+                        *wav_files
+                    ],
+                    inputs=[
+                        audio_input
+                    ]
+                )
+                input_index =  gr.Number(value=0, label="Index")
+
+            btn_get_similar = gr.Button("获取相似音频 Get Similar Score Audio")
+            btn_get_previous_index = gr.Button("上一页 Previous Index")
+            btn_get_next_index = gr.Button("下一页 Next Index")
+
+        
+        gr.Markdown("# 相似音频 similar audio")
+
+        with gr.Column():
+            for _ in range(0,MAX_DISPLAY_AUDIO_NUMBER):
+                audio_output = gr.Audio(
+                    label= "Output Audio",
+                    visible = True,
+                    scale=5,
+                    editable=False
+                )
+                g_gr_audio_list.append(audio_output)
+        
+        btn_get_similar.click(
+            get_next_index_zero,
+            inputs=[
+                audio_input
+            ],
+            outputs=[
+                *g_gr_audio_list,
+                input_index
+            ]
+        )
+
+        btn_get_previous_index.click(
+            get_previous_index,
+            inputs=[
+                audio_input,
+                input_index
+            ],
+            outputs=[
+                *g_gr_audio_list,
+                input_index
+            ]
+        )
+
+        btn_get_next_index.click(
+            get_next_index,
+            inputs=[
+                audio_input,
+                input_index
+            ],
+            outputs=[
+                *g_gr_audio_list,
+                input_index
+            ]
+        )
+
+    #demo.launch(server_name=args.server_name, server_port=args.server_port)
+    demo.launch()