first commit

.gitattributes

@@ -0,0 +1,55 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow 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
+*.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

.gitignore

@@ -0,0 +1,21 @@
+
+.git/
+.idea/
+
+**/flagged/
+**/log/
+**/logs/
+**/__pycache__/
+
+/data/
+/data/raw
+/data/speech
+/docs/
+/dotenv/
+/hub_datasets/
+/trained_models/
+/temp/
+
+/data/**/*.wav
+
+**/*.wav

README.md

@@ -0,0 +1,35 @@
+---
+license: apache-2.0
+size_categories:
+- 100M<n<1B
+---
+## NX Noise
+
+```text
+（1）所有 noise 噪音音频都是大于2秒的。
+（2）noise 噪音段通过分类模型中音频中提取，可能有会包含有语音。
+```
+
+
+### duration
+
+duration; 
+
+| language  | count | duration (s) | duration (h) |
+| :---: | :---: | :---: | :---: |
+| en-PH | 1435 | 5038.2308 | 1.3995 |
+| id-ID | 285 | 1012.845 | 0.2813 |
+| ms-MY | 1084 | 3512.1843 | 0.9756 |
+| pt-BR | 5767 | 20824.6279 | 5.7846 |
+| total | 8571 | 30387.888 | 8.4411 |
+
+
+two second duration; 
+
+| language | count | duration (s) | duration (h) |
+| :---: | :---: | :---: | :---: |
+| en-PH | 1435 | 4070.0 | 1.1306 |
+| id-ID | 285 | 784.0 | 0.2178 |
+| ms-MY | 1084 | 2794.0 | 0.7761 |
+| pt-BR | 5767 | 16452.0 | 4.57 |
+| total | 8571 | 24100.0 | 6.6944 |

download_sound_models.py

@@ -0,0 +1,53 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from pathlib import Path
+
+from huggingface_hub import snapshot_download
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--trained_model_dir",
+        default=(project_path / "trained_models").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--models_repo_id",
+        default="qgyd2021/vm_sound_classification",
+        type=str,
+    )
+    parser.add_argument(
+        "--model_pattern",
+        default="sound-*-ch32.zip",
+        type=str,
+    )
+    parser.add_argument(
+        "--hf_token",
+        default=environment.get("hf_token"),
+        type=str,
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    trained_model_dir = Path(args.trained_model_dir)
+    trained_model_dir.mkdir(parents=True, exist_ok=True)
+
+    _ = snapshot_download(
+        repo_id=args.models_repo_id,
+        allow_patterns=[args.model_pattern],
+        local_dir=trained_model_dir.as_posix(),
+        token=args.hf_token,
+    )
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/make_calling_media_noise_wav/step_1_make_calling_noise.py

@@ -0,0 +1,248 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import os
+from pathlib import Path
+import random
+import shutil
+import tempfile
+import zipfile
+
+import numpy as np
+from scipy.io import wavfile
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+from typing import List
+
+from project_settings import project_path
+from toolbox.cv2.misc import erode, dilate
+from toolbox.torch.utils.data.vocabulary import Vocabulary
+
+
+# language = "en-PH"
+language = "id-ID"
+# language = "ms-MY"
+# language = "pt-BR"
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_file",
+        default=(project_path / "trained_models/sound-8-ch32.zip").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--wav_dir",
+        default=(project_path / f"data/raw/{language}/temp-2").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--output_dir",
+        default=(project_path / f"data/noise/{language}/2025-01-17").as_posix(),
+        type=str
+    )
+
+    parser.add_argument("--min_duration", default=2.0, type=float)
+    parser.add_argument("--win_size", default=2.0, type=int)
+    parser.add_argument("--win_step", default=0.25, type=int)
+    args = parser.parse_args()
+    return args
+
+
+class Tagger(object):
+    def __init__(self,
+                 model_file: str,
+                 win_size: int,
+                 win_step: int,
+                 sample_rate: int = 8000,
+                 ):
+        self.model_file = Path(model_file)
+        self.win_size = win_size
+        self.win_step = win_step
+        self.sample_rate = sample_rate
+
+        self.model: nn.Module = None
+        self.vocabulary: Vocabulary = None
+        self.load_models()
+
+    def load_models(self):
+        with zipfile.ZipFile(self.model_file, "r") as f_zip:
+            out_root = Path(tempfile.gettempdir()) / "vm_sound_classification"
+            if out_root.exists():
+                shutil.rmtree(out_root.as_posix())
+            out_root.mkdir(parents=True, exist_ok=True)
+            f_zip.extractall(path=out_root)
+        tgt_path = out_root / self.model_file.stem
+        jit_model_file = tgt_path / "trace_model.zip"
+        vocab_path = tgt_path / "vocabulary"
+
+        vocabulary = Vocabulary.from_files(vocab_path.as_posix())
+
+        with open(jit_model_file.as_posix(), "rb") as f:
+            model = torch.jit.load(f)
+        model.eval()
+
+        shutil.rmtree(tgt_path)
+
+        self.model = model
+        self.vocabulary = vocabulary
+        return model, vocabulary
+
+    def tag(self, signal: np.ndarray):
+        signal_length = len(signal)
+        win_size = int(self.win_size * self.sample_rate)
+        win_step = int(self.win_step * self.sample_rate)
+
+        signal = np.concatenate([
+            np.zeros(shape=(win_size // 2,), dtype=np.int16),
+            signal,
+            np.zeros(shape=(win_size // 2,), dtype=np.int16),
+        ])
+
+        result = list()
+        for i in range(0, signal_length, win_step):
+            sub_signal = signal[i: i+win_size]
+            if len(sub_signal) < win_size:
+                break
+
+            inputs = torch.tensor(sub_signal, dtype=torch.float32)
+            inputs = torch.unsqueeze(inputs, dim=0)
+
+            probs = self.model(inputs)
+
+            probs = probs.tolist()[0]
+            argidx = np.argmax(probs)
+            label_str = self.vocabulary.get_token_from_index(argidx, namespace="labels")
+            prob = probs[argidx]
+            result.append(label_str)
+
+        return result
+
+
+def correct_labels(labels: List[str]):
+
+    labels = erode(labels, erode_label="noise", n=2)
+    labels = dilate(labels, dilate_label="noise", n=2)
+    return labels
+
+
+def split_signal_by_labels(signal: np.ndarray, labels: List[str]):
+    l = len(labels)
+
+    noise_list = list()
+    begin = None
+    for idx, label in enumerate(labels):
+        if label == "noise":
+            if begin is None:
+                begin = idx
+        elif label != "noise":
+            if begin is not None:
+                noise_list.append((begin, idx))
+                begin = None
+        else:
+            pass
+    else:
+        if begin is not None:
+            noise_list.append((begin, l))
+
+    result = list()
+
+    win_size = signal.shape[0] / l
+    for begin, end in noise_list:
+        begin = int(begin * win_size)
+        end = int(end * win_size)
+
+        sub_signal = signal[begin: end + 1]
+        result.append({
+            "begin": begin,
+            "sub_signal": sub_signal,
+        })
+
+    return result
+
+
+def main():
+    args = get_args()
+
+    max_wave_value = 32768.0
+
+    wav_dir = Path(args.wav_dir)
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    tagger = Tagger(
+        model_file=args.model_file,
+        win_size=args.win_size,
+        win_step=args.win_step,
+    )
+
+    if not wav_dir.exists():
+        wav_zip = wav_dir.parent / f"{wav_dir.name}.zip"
+        with zipfile.ZipFile(wav_zip, "r") as f_zip:
+            wav_dir.mkdir(parents=True, exist_ok=True)
+            f_zip.extractall(path=wav_dir)
+
+    wav_list = list(wav_dir.glob("**/active_media_r_*.wav"))
+    # wav_list = list(wav_dir.glob("**/*.wav"))
+    random.shuffle(wav_list)
+
+    count = 0
+    for filename in tqdm(wav_list):
+        filename = Path(filename)
+        if filename.parts[-2] in ("bell", "music"):
+            continue
+        try:
+            sample_rate, signal = wavfile.read(filename)
+        except UnboundLocalError as e:
+            continue
+        if sample_rate != 8000:
+            raise AssertionError
+
+        if signal.ndim == 2:
+            signal = signal[:, 0]
+
+        if len(signal) < 0.3 * sample_rate:
+            print("remove file: {}".format(filename.as_posix()))
+            os.remove(filename.as_posix())
+            continue
+
+        signal_ = signal / max_wave_value
+
+        labels = tagger.tag(signal_)
+        labels = correct_labels(labels)
+
+        if "noise" not in labels:
+            continue
+
+        sub_signal_list = split_signal_by_labels(signal, labels)
+
+        for i, sub_signal_group in enumerate(sub_signal_list):
+            to_filename = output_dir / "{}_{}.wav".format(filename.stem, i)
+            if to_filename.exists():
+                raise AssertionError
+
+            sub_signal = sub_signal_group["sub_signal"]
+
+            sub_signal = np.array(sub_signal, dtype=np.int16)
+            if len(sub_signal) < sample_rate * args.min_duration:
+                continue
+
+            wavfile.write(
+                filename=to_filename,
+                rate=sample_rate,
+                data=sub_signal
+            )
+            count += 1
+
+        print("remove file: {}".format(filename.as_posix()))
+        os.remove(filename.as_posix())
+
+        # if count > 200:
+        #     break
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/make_calling_media_noise_wav/step_2_make_calling_speech.py

@@ -0,0 +1,245 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+因为 step 1 中已将能提取出 noise 的音频删除了，所以此步骤中提取的 speech 包含 noise 的可能性更小。
+"""
+import argparse
+import os
+from pathlib import Path
+import random
+import shutil
+import tempfile
+import zipfile
+
+import numpy as np
+from scipy.io import wavfile
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+from typing import List
+
+from project_settings import project_path
+from toolbox.cv2.misc import erode, dilate
+from toolbox.torch.utils.data.vocabulary import Vocabulary
+
+
+# language = "en-PH"
+language = "id-ID"
+# language = "ms-MY"
+# language = "pt-BR"
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_file",
+        default=(project_path / "trained_models/sound-8-ch32.zip").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--wav_dir",
+        default=(project_path / f"data/raw/{language}/temp-2").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--output_dir",
+        default=(project_path / f"data/speech/{language}/2025-01-17").as_posix(),
+        type=str
+    )
+    parser.add_argument("--min_duration", default=4.0, type=float)
+    parser.add_argument("--win_size", default=2.0, type=int)
+    parser.add_argument("--win_step", default=0.25, type=int)
+    args = parser.parse_args()
+    return args
+
+
+class Tagger(object):
+    def __init__(self,
+                 model_file: str,
+                 win_size: int,
+                 win_step: int,
+                 sample_rate: int = 8000,
+                 ):
+        self.model_file = Path(model_file)
+        self.win_size = win_size
+        self.win_step = win_step
+        self.sample_rate = sample_rate
+
+        self.model: nn.Module = None
+        self.vocabulary: Vocabulary = None
+        self.load_models()
+
+    def load_models(self):
+        with zipfile.ZipFile(self.model_file, "r") as f_zip:
+            out_root = Path(tempfile.gettempdir()) / "vm_sound_classification"
+            if out_root.exists():
+                shutil.rmtree(out_root.as_posix())
+            out_root.mkdir(parents=True, exist_ok=True)
+            f_zip.extractall(path=out_root)
+        tgt_path = out_root / self.model_file.stem
+        jit_model_file = tgt_path / "trace_model.zip"
+        vocab_path = tgt_path / "vocabulary"
+
+        vocabulary = Vocabulary.from_files(vocab_path.as_posix())
+
+        with open(jit_model_file.as_posix(), "rb") as f:
+            model = torch.jit.load(f)
+        model.eval()
+
+        shutil.rmtree(tgt_path)
+
+        self.model = model
+        self.vocabulary = vocabulary
+        return model, vocabulary
+
+    def tag(self, signal: np.ndarray):
+        signal_length = len(signal)
+        win_size = int(self.win_size * self.sample_rate)
+        win_step = int(self.win_step * self.sample_rate)
+
+        signal = np.concatenate([
+            np.zeros(shape=(win_size // 2,), dtype=np.int16),
+            signal,
+            np.zeros(shape=(win_size // 2,), dtype=np.int16),
+        ])
+
+        result = list()
+        for i in range(0, signal_length, win_step):
+            sub_signal = signal[i: i+win_size]
+            if len(sub_signal) < win_size:
+                break
+
+            inputs = torch.tensor(sub_signal, dtype=torch.float32)
+            inputs = torch.unsqueeze(inputs, dim=0)
+
+            probs = self.model(inputs)
+
+            probs = probs.tolist()[0]
+            argidx = np.argmax(probs)
+            label_str = self.vocabulary.get_token_from_index(argidx, namespace="labels")
+            prob = probs[argidx]
+            result.append(label_str)
+
+        return result
+
+
+def correct_labels(labels: List[str]):
+
+    labels = erode(labels, erode_label="noise", n=2)
+    # labels = dilate(labels, dilate_label="noise", n=2)
+
+    return labels
+
+
+def split_signal_by_labels(signal: np.ndarray, labels: List[str]):
+    l = len(labels)
+
+    noise_list = list()
+    begin = None
+    for idx, label in enumerate(labels):
+        if label == "voice":
+            if begin is None:
+                begin = idx
+        elif label != "voice":
+            if begin is not None:
+                noise_list.append((begin, idx))
+                begin = None
+        else:
+            pass
+    else:
+        if begin is not None:
+            noise_list.append((begin, l))
+
+    result = list()
+
+    win_size = signal.shape[0] / l
+    for begin, end in noise_list:
+        begin = int(begin * win_size)
+        end = int(end * win_size)
+
+        sub_signal = signal[begin: end + 1]
+        result.append({
+            "begin": begin,
+            "sub_signal": sub_signal,
+        })
+
+    return result
+
+
+def main():
+    args = get_args()
+
+    max_wave_value = 32768.0
+
+    wav_dir = Path(args.wav_dir)
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    tagger = Tagger(
+        model_file=args.model_file,
+        win_size=args.win_size,
+        win_step=args.win_step,
+    )
+
+    wav_list = list(wav_dir.glob("**/active_media_r_*.wav"))
+    # wav_list = list(wav_dir.glob("**/*.wav"))
+    random.shuffle(wav_list)
+
+    count = 0
+    for filename in tqdm(wav_list):
+        filename = Path(filename)
+        if filename.parts[-2] in ("bell", "music"):
+            continue
+        try:
+            sample_rate, signal = wavfile.read(filename)
+        except UnboundLocalError as e:
+            continue
+        if sample_rate != 8000:
+            raise AssertionError
+
+        if signal.ndim == 2:
+            signal = signal[:, 0]
+
+        if len(signal) < 0.3 * sample_rate:
+            print("remove file: {}".format(filename.as_posix()))
+            os.remove(filename.as_posix())
+            continue
+
+        signal_ = signal / max_wave_value
+
+        labels = tagger.tag(signal_)
+        labels = correct_labels(labels)
+
+        if "voice" not in labels:
+            continue
+
+        sub_signal_list = split_signal_by_labels(signal, labels)
+
+        for i, sub_signal_group in enumerate(sub_signal_list):
+            to_filename = output_dir / "{}_{}.wav".format(filename.stem, i)
+            if to_filename.exists():
+                raise AssertionError
+
+            sub_signal = sub_signal_group["sub_signal"]
+
+            sub_signal = np.array(sub_signal, dtype=np.int16)
+            if len(sub_signal) < sample_rate * args.min_duration:
+                continue
+
+            wavfile.write(
+                filename=to_filename,
+                rate=sample_rate,
+                data=sub_signal
+            )
+            count += 1
+
+        print("remove file: {}".format(filename.as_posix()))
+        os.remove(filename.as_posix())
+
+        # if count > 200:
+        #     break
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/total_duration.py

@@ -0,0 +1,70 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from collections import defaultdict
+from pathlib import Path
+
+import librosa
+from mpmath.libmp import round_down
+from tqdm import tqdm
+
+from project_settings import project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--noise_dir",
+        default=(project_path / "data/noise").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    counter = defaultdict(int)
+    duration_counter = defaultdict(float)
+    two_second_duration_counter = defaultdict(float)
+
+    noise_dir = Path(args.noise_dir)
+    for filename in tqdm(list(noise_dir.glob("**/*.wav"))):
+        if filename.parts[-4] == "noise":
+            language = filename.parts[-3]
+        elif filename.parts[-3] == "noise":
+            language = filename.parts[-2]
+        else:
+            raise AssertionError
+
+        y, sr = librosa.load(filename, sr=None)
+        duration = librosa.get_duration(y=y, sr=sr)
+        two_second_duration = duration // 2 * 2
+
+        counter[language] += 1
+        duration_counter[language] += round(duration, 4)
+        two_second_duration_counter[language] += round(two_second_duration, 4)
+
+    total_count = sum(counter.values())
+    total_duration = sum(duration_counter.values())
+    row = "\nduration; \n\n"
+    row += "| language  | count | duration (s) | duration (h) |\n| :---: | :---: | :---: | :---: |\n"
+    for k, v in duration_counter.items():
+        row += f"| {k} | {counter[k]} | {round(v, 4)} | {round(v / 3600, 4)} |\n"
+    row += f"| total | {total_count} | {round(total_duration, 4)} | {round(total_duration / 3600, 4)} |\n"
+    print(row)
+
+    total_duration = sum(two_second_duration_counter.values())
+    row = "\ntwo second duration; \n\n"
+    row += "| language | count | duration (s) | duration (h) |\n| :---: | :---: | :---: | :---: |\n"
+    for k, v in two_second_duration_counter.items():
+        row += f"| {k} | {counter[k]} | {round(v, 4)} | {round(v / 3600, 4)} |\n"
+    row += f"| total | {total_count} | {round(total_duration, 4)} | {round(total_duration / 3600, 4)} |\n"
+    print(row)
+
+    return
+
+
+if __name__ == '__main__':
+    main()

install.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+
+# bash install.sh --stage 2 --stop_stage 2 --system_version centos
+
+
+python_version=3.12
+system_version="centos";
+
+verbose=true;
+stage=-1
+stop_stage=0
+
+
+# parse options
+while true; do
+  [ -z "${1:-}" ] && break;  # break if there are no arguments
+  case "$1" in
+    --*) name=$(echo "$1" | sed s/^--// | sed s/-/_/g);
+      eval '[ -z "${'"$name"'+xxx}" ]' && echo "$0: invalid option $1" 1>&2 && exit 1;
+      old_value="(eval echo \\$$name)";
+      if [ "${old_value}" == "true" ] || [ "${old_value}" == "false" ]; then
+        was_bool=true;
+      else
+        was_bool=false;
+      fi
+
+      # Set the variable to the right value-- the escaped quotes make it work if
+      # the option had spaces, like --cmd "queue.pl -sync y"
+      eval "${name}=\"$2\"";
+
+      # Check that Boolean-valued arguments are really Boolean.
+      if $was_bool && [[ "$2" != "true" && "$2" != "false" ]]; then
+        echo "$0: expected \"true\" or \"false\": $1 $2" 1>&2
+        exit 1;
+      fi
+      shift 2;
+      ;;
+
+    *) break;
+  esac
+done
+
+work_dir="$(pwd)"
+
+
+if [ ${stage} -le 1 ] && [ ${stop_stage} -ge 1 ]; then
+  $verbose && echo "stage 1: download sound models"
+  cd "${work_dir}" || exit 1;
+
+  python download_sound_models.py
+
+fi
+
+
+if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
+  $verbose && echo "stage 3: install python"
+  cd "${work_dir}" || exit 1;
+
+  sh ./script/install_python.sh --python_version "${python_version}" --system_version "${system_version}"
+fi
+
+
+if [ ${stage} -le 4 ] && [ ${stop_stage} -ge 4 ]; then
+  $verbose && echo "stage 4: create virtualenv"
+
+  # /usr/local/python-3.6.5/bin/virtualenv vm_sound_classification
+  # source /data/local/bin/vm_sound_classification/bin/activate
+  /usr/local/python-${python_version}/bin/pip3 install virtualenv
+  mkdir -p /data/local/bin
+  cd /data/local/bin || exit 1;
+  /usr/local/python-${python_version}/bin/virtualenv vm_sound_classification
+
+fi

main.py

@@ -0,0 +1,45 @@
+import argparse
+
+from datasets import load_dataset
+
+from project_settings import project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_path",
+        default="nx_noise.py",
+        # default="E:/Users/tianx/HuggingDatasets/nx_noise/nx_noise.py",
+        type=str
+    )
+    parser.add_argument("--dataset_name", default="en-PH", type=str)
+    parser.add_argument(
+        "--dataset_cache_dir",
+        default=(project_path / "hub_datasets").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    dataset = load_dataset(
+        path=args.dataset_path,
+        name=args.dataset_name,
+        cache_dir=args.dataset_cache_dir,
+        # streaming=True,
+        trust_remote_code=True,
+    )
+    # print(dataset.builder_configs)
+    for sample in dataset["train"]:
+        print(sample)
+        print("-" * 150)
+
+    return
+
+
+if __name__ == '__main__':
+    main()

nx_noise.py

@@ -0,0 +1,83 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from pathlib import Path
+
+import datasets
+import librosa
+
+
+_DATA_URL_MAP = {
+    "en-PH": "data/noise/en-PH.zip",
+
+}
+
+_CITATION = """\
+@dataset{nx_noise,
+  author       = {Xing Tian},
+  title        = {nx noise},
+  month        = jan,
+  year         = 2025,
+  publisher    = {Xing Tian},
+  version      = {1.0},
+}
+"""
+
+
+_DESCRIPTION = """noise from user side in calling."""
+
+
+class NXNoise(datasets.GeneratorBasedBuilder):
+    VERSION = datasets.Version("1.0.0")
+
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="en-PH", version=VERSION, description="noise from en-PH"),
+    ]
+
+    def _info(self):
+        features = datasets.Features(
+            {
+                "audio": datasets.Audio(),
+                "duration": datasets.Value("float16"),
+            }
+        )
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            supervised_keys=None,
+            homepage="",
+            license="",
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        """Returns SplitGenerators."""
+        data_url = _DATA_URL_MAP.get(self.config.name)
+        if data_url is None:
+            raise AssertionError(f"subset {self.config.name} is not available.")
+
+        archive_path = dl_manager.download_and_extract(data_url)
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={"archive_path": archive_path, "dl_manager": dl_manager},
+            ),
+        ]
+
+    def _generate_examples(self, archive_path, dl_manager):
+        """Yields examples."""
+        archive_path = Path(archive_path)
+
+        sample_idx = 0
+        for filename in archive_path.glob("**/*.wav"):
+            y, sr = librosa.load(filename, sr=None)
+            yield sample_idx, {
+                "audio": filename.as_posix(),
+                "duration": round(librosa.get_duration(y=y, sr=sr), 4),
+            }
+            sample_idx += 1
+
+
+if __name__ == '__main__':
+    pass

project_settings.py

@@ -0,0 +1,19 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+from pathlib import Path
+
+from toolbox.os.environment import EnvironmentManager
+
+
+project_path = os.path.abspath(os.path.dirname(__file__))
+project_path = Path(project_path)
+
+environment = EnvironmentManager(
+    path=os.path.join(project_path, "dotenv"),
+    env=os.environ.get("environment", "dev"),
+)
+
+
+if __name__ == "__main__":
+    pass

requirements.txt

@@ -0,0 +1,5 @@
+librosa==0.10.2.post1
+datasets==3.2.0
+python-dotenv==1.0.1
+torch==2.5.1
+python_speech_features==0.6

toolbox/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/cv2/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/cv2/misc.py

@@ -0,0 +1,137 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from typing import List, Union
+
+
+def erode(labels: List[Union[str, int]], erode_label: Union[str, int], n: int = 1):
+    """
+    遍历 labels 列表, 将连续的 erode_label 标签侵蚀 n 个.
+    """
+    result = list()
+    in_span = False
+    count = 0
+    for idx, label in enumerate(labels):
+        if label == erode_label:
+            if not in_span:
+                in_span = True
+                count = 0
+            if count < n:
+                if len(result) == 0:
+                    result.append(label)
+                else:
+                    result.append(result[-1])
+                count += 1
+                continue
+            else:
+                result.append(label)
+                continue
+        elif label != erode_label:
+            if in_span:
+                in_span = False
+
+                for i in range(min(len(result), n)):
+                    result[-i-1] = label
+                result.append(label)
+                continue
+            else:
+                result.append(label)
+                continue
+
+        result.append(label)
+    return result
+
+
+def dilate(labels: List[Union[str, int]], dilate_label: Union[str, int], n: int = 1):
+    """
+    遍历 labels 列表, 将连续的 dilate_label 标签扩张 n 个.
+    """
+    result = list()
+    in_span = False
+    count = float('inf')
+    for idx, label in enumerate(labels):
+        if count < n:
+            result.append(dilate_label)
+            count += 1
+            continue
+        if label == dilate_label:
+            if not in_span:
+                in_span = True
+
+                for i in range(min(len(result), n)):
+                    result[-i-1] = label
+                result.append(label)
+                continue
+            else:
+                result.append(label)
+                continue
+        else:
+            if in_span:
+                in_span = False
+                result.append(dilate_label)
+                count = 1
+                continue
+            else:
+                result.append(label)
+                continue
+
+    return result
+
+
+def demo1():
+    labels = [
+        'voice', 'mute', 'mute', 'voice', 'voice', 'voice', 'voice', 'bell', 'bell', 'bell', 'mute', 'mute', 'mute', 'voice',
+    ]
+
+    result = erode(
+        labels=labels,
+        erode_label='voice',
+        n=1,
+
+    )
+    print(len(labels))
+    print(len(result))
+    print(result)
+    return
+
+
+def demo2():
+    labels = [
+        'voice', 'mute', 'mute', 'voice', 'voice', 'voice', 'voice', 'bell', 'bell', 'bell', 'mute', 'mute', 'mute', 'voice',
+    ]
+
+    result = dilate(
+        labels=labels,
+        dilate_label='voice',
+        n=2,
+
+    )
+    print(len(labels))
+    print(len(result))
+    print(result)
+
+    return
+
+
+def demo3():
+    import time
+    labels = ['mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'voice', 'bell', 'bell', 'bell', 'bell', 'bell', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'bell', 'bell', 'bell', 'bell', 'bell', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'bell', 'bell', 'bell', 'bell', 'bell', 'bell', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute', 'mute']
+
+    begin = time.time()
+    labels = erode(labels, erode_label='music', n=1)
+    labels = dilate(labels, dilate_label='music', n=1)
+
+    labels = dilate(labels, dilate_label='voice', n=2)
+    labels = erode(labels, erode_label='voice', n=2)
+    labels = erode(labels, erode_label='voice', n=1)
+    labels = dilate(labels, dilate_label='voice', n=3)
+
+    cost = time.time() - begin
+    print(cost)
+    print(labels)
+    return
+
+
+if __name__ == '__main__':
+    # demo1()
+    # demo2()
+    demo3()

toolbox/json/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/json/misc.py

@@ -0,0 +1,63 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from typing import Callable
+
+
+def traverse(js, callback: Callable, *args, **kwargs):
+    if isinstance(js, list):
+        result = list()
+        for l in js:
+            l = traverse(l, callback, *args, **kwargs)
+            result.append(l)
+        return result
+    elif isinstance(js, tuple):
+        result = list()
+        for l in js:
+            l = traverse(l, callback, *args, **kwargs)
+            result.append(l)
+        return tuple(result)
+    elif isinstance(js, dict):
+        result = dict()
+        for k, v in js.items():
+            k = traverse(k, callback, *args, **kwargs)
+            v = traverse(v, callback, *args, **kwargs)
+            result[k] = v
+        return result
+    elif isinstance(js, int):
+        return callback(js, *args, **kwargs)
+    elif isinstance(js, str):
+        return callback(js, *args, **kwargs)
+    else:
+        return js
+
+
+def demo1():
+    d = {
+        "env": "ppe",
+        "mysql_connect": {
+            "host": "$mysql_connect_host",
+            "port": 3306,
+            "user": "callbot",
+            "password": "NxcloudAI2021!",
+            "database": "callbot_ppe",
+            "charset": "utf8"
+        },
+        "es_connect": {
+            "hosts": ["10.20.251.8"],
+            "http_auth": ["elastic", "ElasticAI2021!"],
+            "port": 9200
+        }
+    }
+
+    def callback(s):
+        if isinstance(s, str) and s.startswith('$'):
+            return s[1:]
+        return s
+
+    result = traverse(d, callback=callback)
+    print(result)
+    return
+
+
+if __name__ == '__main__':
+    demo1()

toolbox/os/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/os/environment.py

@@ -0,0 +1,114 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import json
+import os
+
+from dotenv import load_dotenv
+from dotenv.main import DotEnv
+
+from toolbox.json.misc import traverse
+
+
+class EnvironmentManager(object):
+    def __init__(self, path, env, override=False):
+        filename = os.path.join(path, '{}.env'.format(env))
+        self.filename = filename
+
+        load_dotenv(
+            dotenv_path=filename,
+            override=override
+        )
+
+        self._environ = dict()
+
+    def open_dotenv(self, filename: str = None):
+        filename = filename or self.filename
+        dotenv = DotEnv(
+            dotenv_path=filename,
+            stream=None,
+            verbose=False,
+            interpolate=False,
+            override=False,
+            encoding="utf-8",
+        )
+        result = dotenv.dict()
+        return result
+
+    def get(self, key, default=None, dtype=str):
+        result = os.environ.get(key)
+        if result is None:
+            if default is None:
+                result = None
+            else:
+                result = default
+        else:
+            result = dtype(result)
+        self._environ[key] = result
+        return result
+
+
+_DEFAULT_DTYPE_MAP = {
+    'int': int,
+    'float': float,
+    'str': str,
+    'json.loads': json.loads
+}
+
+
+class JsonConfig(object):
+    """
+    将 json 中, 形如 `$float:threshold` 的值, 处理为:
+    从环境变量中查到 threshold, 再将其转换为 float 类型.
+    """
+    def __init__(self, dtype_map: dict = None, environment: EnvironmentManager = None):
+        self.dtype_map = dtype_map or _DEFAULT_DTYPE_MAP
+        self.environment = environment or os.environ
+
+    def sanitize_by_filename(self, filename: str):
+        with open(filename, 'r', encoding='utf-8') as f:
+            js = json.load(f)
+
+        return self.sanitize_by_json(js)
+
+    def sanitize_by_json(self, js):
+        js = traverse(
+            js,
+            callback=self.sanitize,
+            environment=self.environment
+        )
+        return js
+
+    def sanitize(self, string, environment):
+        """支持 $ 符开始的, 环境变量配置"""
+        if isinstance(string, str) and string.startswith('$'):
+            dtype, key = string[1:].split(':')
+            dtype = self.dtype_map[dtype]
+
+            value = environment.get(key)
+            if value is None:
+                raise AssertionError('environment not exist. key: {}'.format(key))
+
+            value = dtype(value)
+            result = value
+        else:
+            result = string
+        return result
+
+
+def demo1():
+    import json
+
+    from settings import project_path
+
+    environment = EnvironmentManager(
+        path=os.path.join(project_path, 'server/callbot_server/dotenv'),
+        env='dev',
+    )
+    init_scenes = environment.get(key='init_scenes', dtype=json.loads)
+    print(init_scenes)
+    print(environment._environ)
+    return
+
+
+if __name__ == '__main__':
+    demo1()

toolbox/os/other.py

@@ -0,0 +1,9 @@
+import os
+import inspect
+
+
+def pwd():
+    """你在哪个文件调用此函数, 它就会返回那个文件所在的 dir 目标"""
+    frame = inspect.stack()[1]
+    module = inspect.getmodule(frame[0])
+    return os.path.dirname(os.path.abspath(module.__file__))

toolbox/python_speech_features/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/python_speech_features/misc.py

@@ -0,0 +1,104 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+
+import cv2 as cv
+import numpy as np
+from python_speech_features import sigproc
+from python_speech_features import mfcc
+from sklearn import preprocessing
+
+
+def wave2spectrum(sample_rate, wave, winlen=0.025, winstep=0.01, nfft=512):
+    """计算功率谱图像"""
+    frames = sigproc.framesig(
+        sig=wave,
+        frame_len=winlen * sample_rate,
+        frame_step=winstep * sample_rate,
+        winfunc=np.hamming
+    )
+    spectrum = sigproc.powspec(
+        frames=frames,
+        NFFT=nfft
+    )
+    spectrum = spectrum.T
+    return spectrum
+
+
+def wave2spectrum_image(
+    wave, sample_rate,
+    xmax=10, xmin=-50,
+    winlen=0.025, winstep=0.01, nfft=512,
+    n_low_freq=None
+):
+    """
+    :return: numpy.ndarray, shape=(time_step, n_dim)
+    """
+    spectrum = wave2spectrum(
+        sample_rate, wave,
+        winlen=winlen,
+        winstep=winstep,
+        nfft=nfft,
+    )
+    spectrum = np.log(spectrum, out=np.zeros_like(spectrum), where=(spectrum != 0))
+    spectrum = spectrum.T
+    gray = 255 * (spectrum - xmin) / (xmax - xmin)
+    gray = np.array(gray, dtype=np.uint8)
+    if n_low_freq is not None:
+        gray = gray[:, :n_low_freq]
+
+    return gray
+
+
+def compute_delta(specgram: np.ndarray, win_length: int = 5):
+    """
+    :param specgram: shape=[time_steps, n_mels]
+    :param win_length:
+    :return:
+    """
+    n = (win_length - 1) // 2
+
+    specgram = np.array(specgram, dtype=np.float32)
+
+    kernel = np.arange(-n, n + 1, 1)
+    kernel = np.reshape(kernel, newshape=(2 * n + 1, 1))
+    kernel = np.array(kernel, dtype=np.float32) / 10
+
+    delta = cv.filter2D(
+        src=specgram,
+        ddepth=cv.CV_32F,
+        kernel=kernel,
+    )
+    return delta
+
+
+def delta_mfcc_feature(signal, sample_rate):
+    """
+    为 GMM UBM 声纹识别模型, 编写此代码.
+
+    https://github.com/pventrella20/Speaker_identification_-GMM-UBM-
+    https://github.com/MChamith/Speaker_verification_gmm_ubm
+
+    :param signal: np.ndarray
+    :param sample_rate: frequenza del file audio
+    :return:
+    """
+
+    # shape=[time_steps, n_mels]
+    mfcc_feat = mfcc(
+        signal=signal,
+        samplerate=sample_rate,
+        winlen=0.025,
+        winstep=0.01,
+        numcep=20,
+        appendEnergy=True
+    )
+
+    mfcc_feat = preprocessing.scale(mfcc_feat)
+    delta = compute_delta(mfcc_feat)
+    combined = np.hstack(tup=(mfcc_feat, delta))
+    return combined
+
+
+if __name__ == '__main__':
+    pass

toolbox/python_speech_features/silence_detect.py

@@ -0,0 +1,81 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import numpy as np
+from python_speech_features import sigproc
+
+
+def calc_energy(signal, samplerate=16000, winlen=0.025, winstep=0.01):
+    """
+    任意信号都可以看作是在电阻R=1 的电路上的电流 I. 则能量为 I^2
+    """
+    signal = np.array(signal, dtype=np.float32)
+    power = np.square(signal)
+
+    # 分帧
+    frames = sigproc.framesig(power, winlen*samplerate, winstep*samplerate)
+    # 各帧能量总和.
+    energy = np.mean(frames, axis=-1)
+    return energy
+
+
+def calc_zero_crossing_rate(signal, samplerate=16000, winlen=0.025, winstep=0.01):
+    """过零率. """
+    signal = np.where(signal >= 0, 1, -1)
+    cross_zero = np.where(signal[1:] != signal[:-1], 1, 0)
+
+    frames = sigproc.framesig(cross_zero, winlen*samplerate, winstep*samplerate)
+    _, n = frames.shape
+    cross_zero_rate = np.mean(frames, axis=-1)
+
+    return cross_zero_rate
+
+
+def detect_silence(signal, samplerate=16000, winlen=0.025, winstep=0.01, min_energy=0.01, min_cross_zero_rate=0.05):
+    """静音段检测"""
+    energy = calc_energy(
+        signal=signal,
+        samplerate=samplerate,
+        winlen=winlen,
+        winstep=winstep,
+    )
+    cross_zero_rate = calc_zero_crossing_rate(
+        signal=signal,
+        samplerate=samplerate,
+        winlen=winlen,
+        winstep=winstep,
+    )
+    energy = energy < min_energy
+    cross_zero_rate = cross_zero_rate < min_cross_zero_rate
+    silence_signal = np.array(energy + cross_zero_rate, dtype=np.bool)
+    silence_signal = silence_signal.tolist()
+
+    frame_len = int(sigproc.round_half_up(winlen*samplerate))
+    frame_step = int(sigproc.round_half_up(winstep*samplerate))
+
+    silence_list = list()
+    last_s = False
+    for idx, s in enumerate(silence_signal):
+        if s is True:
+            if last_s is True:
+                silence = silence_list.pop(-1)
+                begin = silence[0]
+                count = silence[1]
+                silence_list.append([begin, count + 1])
+            else:
+                begin = frame_step * idx
+                silence_list.append([begin, 1])
+
+        last_s = s
+
+    result = list()
+    for silence in silence_list:
+        begin = silence[0]
+        count = silence[1]
+        end = begin + frame_step * (count - 1) + frame_len
+        result.append([begin, end])
+
+    return result
+
+
+if __name__ == '__main__':
+    pass

toolbox/python_speech_features/wave_features.py

@@ -0,0 +1,111 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import numpy as np
+
+from smart.python_speech_features.silence_detect import detect_silence
+
+
+def calc_wave_features(signal, sample_rate):
+    assert signal.dtype == np.int16
+    assert sample_rate == 8000
+
+    signal = np.array(signal, dtype=np.float32)
+    # plt.plot(signal)
+    # plt.show()
+
+    l = len(signal)
+
+    # 均值
+    mean = np.mean(signal)
+
+    # 方差
+    var = np.var(signal)
+
+    # 百分位数
+    per = np.percentile(signal, q=[1, 25, 50, 75, 99])
+    per1, per25, per50, per75, per99 = per
+
+    # 静音段占比
+    silences = detect_silence(
+        signal=signal,
+        samplerate=sample_rate,
+        min_energy=120,
+        min_cross_zero_rate=0.01
+    )
+    silence_total = 0
+    for silence in silences:
+        li = silence[1] - silence[0]
+        silence_total += li
+    silence_rate = silence_total / l
+
+    # 非静音段方差
+    last_e = 0
+    non_silences = list()
+    for silence in silences:
+        b, e = silence
+        if b > last_e:
+            non_silences.append([last_e, b])
+        last_e = e
+    else:
+        if l > last_e:
+            non_silences.append([last_e, l])
+
+    # 静音段的数量
+    silence_count = len(non_silences)
+
+    if silence_count == 0:
+        mean_non_silence = 0
+        var_non_silence = 0
+        var_var_non_silence = 0
+        var_non_silence_rate = 1
+    else:
+        signal_non_silences = list()
+        for non_silence in non_silences:
+            b, e = non_silence
+            signal_non_silences.append(signal[b: e])
+
+        # 非静音段, 各段方差的方差.
+        v = list()
+        for signal_non_silence in signal_non_silences:
+            v.append(np.var(signal_non_silence))
+        var_var_non_silence = np.var(v)
+
+        signal_non_silences = np.concatenate(signal_non_silences)
+        # 非静音段整体均值
+        mean_non_silence = np.mean(signal_non_silences)
+        # 非静音段整体方差
+        var_non_silence = np.var(signal_non_silences)
+        # 非静音段整体方差 除以 整体方差
+        var_non_silence_rate = var_non_silence / var
+
+    # 全段, 分段方差的方差
+    sub_signal_list = np.split(signal, 20)
+
+    whole_var = list()
+    for sub_signal in sub_signal_list:
+        sub_var = np.var(sub_signal)
+        whole_var.append(sub_var)
+    var_var_whole = np.var(whole_var)
+
+    result = {
+        'mean': mean,
+        'var': var,
+        'per1': per1,
+        'per25': per25,
+        'per50': per50,
+        'per75': per75,
+        'per99': per99,
+        'silence_rate': silence_rate,
+        'mean_non_silence': mean_non_silence,
+        'silence_count': silence_count,
+        'var_var_non_silence': var_var_non_silence,
+        'var_non_silence': var_non_silence,
+        'var_non_silence_rate': var_non_silence_rate,
+        'var_var_whole': var_var_whole,
+
+    }
+    return result
+
+
+if __name__ == '__main__':
+    pass

toolbox/torch/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/torch/utils/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/torch/utils/data/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/torch/utils/data/vocabulary.py

@@ -0,0 +1,211 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from collections import defaultdict, OrderedDict
+import os
+from typing import Any, Callable, Dict, Iterable, List, Set
+
+
+def namespace_match(pattern: str, namespace: str):
+    """
+    Matches a namespace pattern against a namespace string.  For example, ``*tags`` matches
+    ``passage_tags`` and ``question_tags`` and ``tokens`` matches ``tokens`` but not
+    ``stemmed_tokens``.
+    """
+    if pattern[0] == '*' and namespace.endswith(pattern[1:]):
+        return True
+    elif pattern == namespace:
+        return True
+    return False
+
+
+class _NamespaceDependentDefaultDict(defaultdict):
+    def __init__(self,
+                 non_padded_namespaces: Set[str],
+                 padded_function: Callable[[], Any],
+                 non_padded_function: Callable[[], Any]) -> None:
+        self._non_padded_namespaces = set(non_padded_namespaces)
+        self._padded_function = padded_function
+        self._non_padded_function = non_padded_function
+        super(_NamespaceDependentDefaultDict, self).__init__()
+
+    def __missing__(self, key: str):
+        if any(namespace_match(pattern, key) for pattern in self._non_padded_namespaces):
+            value = self._non_padded_function()
+        else:
+            value = self._padded_function()
+        dict.__setitem__(self, key, value)
+        return value
+
+    def add_non_padded_namespaces(self, non_padded_namespaces: Set[str]):
+        # add non_padded_namespaces which weren't already present
+        self._non_padded_namespaces.update(non_padded_namespaces)
+
+
+class _TokenToIndexDefaultDict(_NamespaceDependentDefaultDict):
+    def __init__(self, non_padded_namespaces: Set[str], padding_token: str, oov_token: str) -> None:
+        super(_TokenToIndexDefaultDict, self).__init__(non_padded_namespaces,
+                                                       lambda: {padding_token: 0, oov_token: 1},
+                                                       lambda: {})
+
+
+class _IndexToTokenDefaultDict(_NamespaceDependentDefaultDict):
+    def __init__(self, non_padded_namespaces: Set[str], padding_token: str, oov_token: str) -> None:
+        super(_IndexToTokenDefaultDict, self).__init__(non_padded_namespaces,
+                                                       lambda: {0: padding_token, 1: oov_token},
+                                                       lambda: {})
+
+
+DEFAULT_NON_PADDED_NAMESPACES = ("*tags", "*labels")
+DEFAULT_PADDING_TOKEN = '[PAD]'
+DEFAULT_OOV_TOKEN = '[UNK]'
+NAMESPACE_PADDING_FILE = 'non_padded_namespaces.txt'
+
+
+class Vocabulary(object):
+    def __init__(self, non_padded_namespaces: Iterable[str] = DEFAULT_NON_PADDED_NAMESPACES):
+        self._non_padded_namespaces = set(non_padded_namespaces)
+        self._padding_token = DEFAULT_PADDING_TOKEN
+        self._oov_token = DEFAULT_OOV_TOKEN
+        self._token_to_index = _TokenToIndexDefaultDict(self._non_padded_namespaces,
+                                                        self._padding_token,
+                                                        self._oov_token)
+        self._index_to_token = _IndexToTokenDefaultDict(self._non_padded_namespaces,
+                                                        self._padding_token,
+                                                        self._oov_token)
+
+    def add_token_to_namespace(self, token: str, namespace: str = 'tokens') -> int:
+        if token not in self._token_to_index[namespace]:
+            index = len(self._token_to_index[namespace])
+            self._token_to_index[namespace][token] = index
+            self._index_to_token[namespace][index] = token
+            return index
+        else:
+            return self._token_to_index[namespace][token]
+
+    def get_index_to_token_vocabulary(self, namespace: str = 'tokens') -> Dict[int, str]:
+        return self._index_to_token[namespace]
+
+    def get_token_to_index_vocabulary(self, namespace: str = 'tokens') -> Dict[str, int]:
+        return self._token_to_index[namespace]
+
+    def get_token_index(self, token: str, namespace: str = 'tokens') -> int:
+        if token in self._token_to_index[namespace]:
+            return self._token_to_index[namespace][token]
+        else:
+            return self._token_to_index[namespace][self._oov_token]
+
+    def get_token_from_index(self, index: int, namespace: str = 'tokens'):
+        return self._index_to_token[namespace][index]
+
+    def get_vocab_size(self, namespace: str = 'tokens') -> int:
+        return len(self._token_to_index[namespace])
+
+    def save_to_files(self, directory: str):
+        os.makedirs(directory, exist_ok=True)
+        with open(os.path.join(directory, NAMESPACE_PADDING_FILE), 'w', encoding='utf-8') as f:
+            for namespace_str in self._non_padded_namespaces:
+                f.write('{}\n'.format(namespace_str))
+
+        for namespace, token_to_index in self._token_to_index.items():
+            filename = os.path.join(directory, '{}.txt'.format(namespace))
+            with open(filename, 'w', encoding='utf-8') as f:
+                for token, _ in token_to_index.items():
+                    f.write('{}\n'.format(token))
+
+    @classmethod
+    def from_files(cls, directory: str) -> 'Vocabulary':
+        with open(os.path.join(directory, NAMESPACE_PADDING_FILE), 'r', encoding='utf-8') as f:
+            non_padded_namespaces = [namespace_str.strip() for namespace_str in f]
+
+        vocab = cls(non_padded_namespaces=non_padded_namespaces)
+
+        for namespace_filename in os.listdir(directory):
+            if namespace_filename == NAMESPACE_PADDING_FILE:
+                continue
+            if namespace_filename.startswith("."):
+                continue
+            namespace = namespace_filename.replace('.txt', '')
+            if any(namespace_match(pattern, namespace) for pattern in non_padded_namespaces):
+                is_padded = False
+            else:
+                is_padded = True
+            filename = os.path.join(directory, namespace_filename)
+            vocab.set_from_file(filename, is_padded, namespace=namespace)
+
+        return vocab
+
+    def set_from_file(self,
+                      filename: str,
+                      is_padded: bool = True,
+                      oov_token: str = DEFAULT_OOV_TOKEN,
+                      namespace: str = "tokens"
+                      ):
+        if is_padded:
+            self._token_to_index[namespace] = {self._padding_token: 0}
+            self._index_to_token[namespace] = {0: self._padding_token}
+        else:
+            self._token_to_index[namespace] = {}
+            self._index_to_token[namespace] = {}
+
+        with open(filename, 'r', encoding='utf-8') as f:
+            index = 1 if is_padded else 0
+            for row in f:
+                token = str(row).strip()
+                if token == oov_token:
+                    token = self._oov_token
+                self._token_to_index[namespace][token] = index
+                self._index_to_token[namespace][index] = token
+                index += 1
+
+    def convert_tokens_to_ids(self, tokens: List[str], namespace: str = "tokens"):
+        result = list()
+        for token in tokens:
+            idx = self._token_to_index[namespace].get(token)
+            if idx is None:
+                idx = self._token_to_index[namespace][self._oov_token]
+            result.append(idx)
+        return result
+
+    def convert_ids_to_tokens(self, ids: List[int], namespace: str = "tokens"):
+        result = list()
+        for idx in ids:
+            idx = self._index_to_token[namespace][idx]
+            result.append(idx)
+        return result
+
+    def pad_or_truncate_ids_by_max_length(self, ids: List[int], max_length: int, namespace: str = "tokens"):
+        pad_idx = self._token_to_index[namespace][self._padding_token]
+
+        length = len(ids)
+        if length > max_length:
+            result = ids[:max_length]
+        else:
+            result = ids + [pad_idx] * (max_length - length)
+        return result
+
+
+def demo1():
+    import jieba
+
+    vocabulary = Vocabulary()
+    vocabulary.add_token_to_namespace('白天', 'tokens')
+    vocabulary.add_token_to_namespace('晚上', 'tokens')
+
+    text = '不是在白天, 就是在晚上'
+    tokens = jieba.lcut(text)
+
+    print(tokens)
+
+    ids = vocabulary.convert_tokens_to_ids(tokens)
+    print(ids)
+
+    padded_idx = vocabulary.pad_or_truncate_ids_by_max_length(ids, 10)
+    print(padded_idx)
+
+    tokens = vocabulary.convert_ids_to_tokens(padded_idx)
+    print(tokens)
+    return
+
+
+if __name__ == '__main__':
+    demo1()