first commit

.gitignore

@@ -0,0 +1,16 @@
+
+.git/
+.idea/
+
+**/flagged/
+**/log/
+**/logs/
+**/__pycache__/
+
+data/
+docs/
+dotenv/
+trained_models/
+temp/
+
+**/*.xlsx

examples/evaluation/evaluation.py

@@ -0,0 +1,302 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import base64
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../../"))
+
+import pandas as pd
+import requests
+from tqdm import tqdm
+
+from project_settings import project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="127.0.0.1", type=str)
+    parser.add_argument("--port", default=2080, type=int)
+
+    parser.add_argument(
+        "--wav_dir",
+        default=(project_path / "data/wav/65").as_posix(),
+        type=str
+    )
+    parser.add_argument("--country_code", default=65, type=int)
+
+    args = parser.parse_args()
+    return args
+
+
+# 1
+label_map_1 = {
+    "bell": "bell",
+    "caller_id_blocked": "caller_id_blocked",
+    "can_not_be_completed": "can_not_be_completed",
+    "disconnected": "disconnected",
+    "disconnected_or_out_of_service_or_invalid_number": "disconnected_or_out_of_service_or_invalid_number",
+    "mute": "mute",
+    "not_accept_calls": "not_accept_calls",
+    "not_available": "not_available",
+    "out_of_service": "out_of_service",
+    "restricted_or_unavailable": "restricted_or_unavailable",
+}
+
+# 52
+label_map_52 = {
+    "bell": "bell",
+    "mute": "mute",
+
+    "music": "music",
+    "voice": "music",
+
+    "arrears": "out_of_service",
+
+    "busy": "busy",
+
+    "invalid_number": "invalid_number",
+
+    "not_available": "not_available",
+
+    "not_available_or_out_of_service": "not_available_or_out_of_service",
+    "number_paused": "number_paused",
+    "out_of_service": "out_of_service",
+    "restricted": "out_of_service",
+
+    "power_off_or_out_of_service": "power_off_or_out_of_service",
+    "voicemail": "voicemail",
+    "voicemail_is_full": "voicemail_is_full",
+}
+
+# 63
+label_map_63 = {
+    "bell": "bell",
+    "mute": "mute",
+
+    "music": "music",
+    "voice": "music",
+    "noise": "music",
+
+    "busy": "busy",
+    "call_forwarding": "call_forwarding",
+    "can_not_be_completed": "can_not_be_completed",
+    "invalid_number": "invalid_number",
+    "no_route_found": "no_route_found",
+    "not_reachable": "not_reachable",
+    "out_of_service": "out_of_service",
+    "unattended": "unattended",
+    "unattended_or_out_of_coverage_area": "unattended_or_out_of_coverage_area",
+
+}
+
+# 65
+label_map_65 = {
+    "bell": "bell",
+    "mute": "mute",
+
+    "music": "music",
+    "voice": "music",
+    "noise": "music",
+
+    "busy": "busy",
+    "can_not_be_completed": "can_not_be_completed",
+    "invalid_number": "invalid_number",
+    "not_available": "not_available",
+    "not_responding": "not_responding",
+    "out_of_service": "out_of_service",
+}
+
+# 66
+label_map_66 = {
+    "bell": "bell",
+    "mute": "mute",
+
+    "music": "music",
+    "voice": "music",
+    "noise": "music",
+
+    "invalid_number": "invalid_number",
+    "no_answer": "no_answer",
+
+    "not_reachable": "not_reachable",
+    "out_of_service": "out_of_service",
+    "voicemail": "voicemail",
+
+}
+
+# 91
+label_map_91 = {
+    "bell": "bell",
+    "mute": "mute",
+
+    "music": "music",
+    "voice": "music",
+    "noise": "music",
+
+    "noise_music": "music",
+    "noise_mute": "music",
+    "noise_voice": "music",
+
+    "busy": "busy",
+
+    "can_not_connect": "not_reachable",
+    "forwarded": "forwarded",
+    "line_busy": "line_busy",
+    "not_available": "not_available",
+    "not_reachable": "not_reachable",
+    "invalid_number": "invalid_number",
+    "out_of_service": "out_of_service",
+    "out_of_service_area": "out_of_service_area",
+    "power_off": "power_off",
+    "unknown": "music",
+
+}
+
+# 234
+label_map_234 = {
+    "bell": "bell",
+    "mute": "mute",
+
+    "music": "music",
+    "voice": "music",
+    "other": "music",
+
+    "busy": "busy",
+    "on_another_call": "busy",
+
+    "can_not_be_reached": "power_off",
+    "invalid_number": "invalid_number",
+    "not_available": "not_available",
+    "power_off": "power_off",
+    "power_off_or_out_of_service": "power_off",
+    "not_reachable": "power_off",
+
+}
+
+# 254
+label_map_254 = {
+    "bell": "bell",
+    "mute": "mute",
+
+    "music": "music",
+    "voice": "music",
+
+    "busy": "busy",
+    "invalid_number": "invalid_number",
+    "not_available": "not_available",
+    "not_reachable": "power_off",
+    "out_of_service": "out_of_service",
+    "power_off": "power_off",
+
+}
+
+# 255
+label_map_255 = {
+    "bell": "bell",
+    "mute": "mute",
+
+    "busy": "busy",
+    "can_not_be_connected": "can_not_be_connected",
+    "invalid_number": "invalid_number",
+    "no_answer": "no_answer",
+
+
+    "not_available": "not_available",
+    "not_reachable": "not_available",
+
+    "restricted": "restricted",
+    "switched_off_or_not_available": "switched_off_or_not_available",
+}
+
+# 886
+label_map_886 = {
+    "bell": "bell",
+    "mute": "mute",
+
+    "music": "music",
+    "voice": "music",
+    "卡线": "music",
+
+    "busy": "busy",
+    "invalid_number": "invalid_number",
+    "not_available": "not_available",
+    "number_paused": "number_paused",
+
+    "power_off": "power_off",
+    "voicemail": "voicemail",
+}
+
+area_code2label_map = {
+    1: label_map_1,
+    52: label_map_52,
+    63: label_map_63,
+    65: label_map_65,
+    66: label_map_66,
+    91: label_map_91,
+    234: label_map_234,
+    254: label_map_254,
+    255: label_map_255,
+    886: label_map_886,
+
+}
+
+
+def main():
+    args = get_args()
+
+    wav_dir = Path(args.wav_dir)
+
+    url = "http://{host}:{port}/call_status".format(
+        host=args.host,
+        port=args.port,
+    )
+    headers = {
+        "Content-Type": "application/json"
+    }
+
+    label_map = area_code2label_map[args.country_code]
+
+    result = list()
+    for filename in tqdm(wav_dir.glob("*/*.wav")):
+        label = filename.parts[-2]
+        if label not in label_map.keys():
+            continue
+        label = label_map[label]
+
+        with open(filename, "rb") as f:
+            data = f.read()
+
+        base64string = base64.b64encode(data).decode("utf-8")
+
+        data = {
+            "country": args.country_code,
+            "record": base64string
+        }
+
+        resp = requests.post(url, headers=headers, data=json.dumps(data))
+        if resp.status_code != 200:
+            print("request failed, status_code: {}, text: {}.".format(resp.status_code, resp.text))
+            continue
+        js = resp.json()
+        predict = js["result"]["label_id"]
+        result.append({
+            "filename": filename,
+            "target": label,
+            "predict": predict,
+            "correct": 1 if label == predict else 0,
+        })
+
+    version = datetime.now().strftime("%Y%m%d_%H%M")
+    result = pd.DataFrame(result)
+    result.to_excel("evaluation_{}_{}.xlsx".format(args.country_code, version), index=False, encoding="utf_8_sig")
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/make_templates/step_1_wav_classification.py

@@ -0,0 +1,148 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from collections import Counter, defaultdict
+from glob import glob
+from itertools import chain
+import json
+import os
+from pathlib import Path
+import sys
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, '../../'))
+
+import numpy as np
+from scipy.io import wavfile
+import torch
+import torch.nn as nn
+import shutil
+from tqdm import tqdm
+
+from project_settings import project_path
+from toolbox.cv2.misc import show_image
+from toolbox.python_speech_features.misc import wave2spectrum_image
+
+
+area_code = 55
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--model_dir",
+        default=(project_path / "trained_models/early_media_20220721").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--wav_dir",
+        default=(project_path / "data/early_media/{area_code}/wav".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+def demo1():
+    args = get_args()
+
+    model_dir = Path(args.model_dir)
+    wav_dir = Path(args.wav_dir)
+
+    # model
+    seq2seq_encoder = torch.jit.load(model_dir / "seq2seq_encoder.pth")
+    seq2vec_encoder = torch.jit.load(model_dir / "seq2vec_encoder.pth")
+    classification_layer = torch.jit.load(model_dir / "classification_layer.pth")
+    with open(model_dir / "index2token.json", "r", encoding="utf-8") as f:
+        index2token = json.load(f)
+
+    # 读取文件
+    for filename in tqdm(wav_dir.glob("*.wav")):
+        filename: Path = filename
+        # path, fn = os.path.split(filename)
+        try:
+            sample_rate, wave = wavfile.read(filename)
+        except UnboundLocalError:
+            os.remove(filename)
+            continue
+        if sample_rate != 8000:
+            raise AssertionError
+
+        if len(wave) < 1.0 * sample_rate:
+            os.remove(filename.as_posix())
+            continue
+
+        max_wave_value = 32768.0
+        wave = wave / max_wave_value
+
+        array = wave2spectrum_image(
+            wave,
+            sample_rate=8000,
+            xmax=10,
+            xmin=-50,
+            winlen=0.025,
+            winstep=0.01,
+            nfft=512,
+            n_low_freq=100,
+        )
+        # show_image(array.T)
+
+        array = np.array([array], dtype=np.float32)
+        array = torch.tensor(array, dtype=torch.float32)
+        mask: torch.IntTensor = torch.ones(size=array.shape[:-1], device=array.device, dtype=torch.int32)
+
+        array = seq2seq_encoder.forward(array, mask)
+
+        length = array.shape[-2]
+
+        m_win_size = 50
+        m_win_step = 25
+
+        labels = list()
+        idx = 0
+        while True:
+            begin = idx * m_win_step
+            end = begin + m_win_size
+            if end > length:
+                break
+            window = array[:, begin:end, :]
+
+            window = seq2vec_encoder.forward(window)
+
+            logits = classification_layer(window)
+            probs = torch.nn.functional.softmax(logits, dim=-1)
+            label_idx = probs.argmax(dim=-1).item()
+
+            label_str = index2token[str(label_idx)]
+            labels.append(label_str)
+            idx += 1
+
+        counter = Counter(labels)
+        total = sum(counter.values())
+
+        rate_dict = defaultdict(float)
+        for k, v in counter.items():
+            rate_dict[k] = v / total
+
+        if rate_dict["voice"] > 0.1:
+            tgt = filename.parent / "voice"
+        elif rate_dict["music"] > 0.1:
+            tgt = filename.parent / "music"
+        elif rate_dict["bell"] > 0.1:
+            tgt = filename.parent / "bell"
+        else:
+            tgt = filename.parent / "mute"
+
+        tgt.mkdir(exist_ok=True)
+        try:
+            shutil.move(filename.as_posix(), tgt.as_posix())
+        except shutil.Error:
+            fn = tgt / "{}_2.wav".format(filename.stem)
+            shutil.move(filename.as_posix(), fn)
+    return
+
+
+if __name__ == '__main__':
+    demo1()

examples/make_templates/step_2_wav_split.py

@@ -0,0 +1,73 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+ASR:
+https://cloud.tencent.com/product/asr#mod2
+
+https://huggingface.co/spaces/sanchit-gandhi/whisper-large-v2
+https://huggingface.co/spaces/hf-audio/whisper-large-v3
+"""
+import argparse
+from pathlib import Path
+
+import numpy as np
+from python_speech_features import sigproc
+from scipy.io import wavfile
+from tqdm import tqdm
+
+from project_settings import project_path
+
+
+area_code = 91
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--filename",
+        default=(project_path / "data/wav/91/91_wav/voice/91_1699977085057.wav").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--templates_segmented_dir",
+        default=(project_path / "data/early_media_template/{area_code}/segmented".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    parser.add_argument("--win_size", default=2.0, type=float)
+    parser.add_argument("--win_len", default=0.5, type=float)
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    filename = Path(args.filename)
+    templates_segmented_dir = Path(args.templates_segmented_dir)
+
+    templates_segmented_dir.mkdir(parents=True, exist_ok=True)
+
+    sample_rate, signal = wavfile.read(filename)
+
+    frames = sigproc.framesig(
+        sig=signal,
+        frame_len=args.win_size * sample_rate,
+        frame_step=args.win_len * sample_rate,
+        # winfunc=np.hamming
+    )
+
+    for j, frame in enumerate(frames):
+        to_filename = templates_segmented_dir / "{}_{}.wav".format(filename.stem, j)
+
+        frame = np.array(frame, dtype=np.int16)
+        wavfile.write(
+            filename=to_filename,
+            rate=sample_rate,
+            data=frame
+        )
+
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/make_templates/step_3_move_by_template.py

@@ -0,0 +1,229 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from collections import defaultdict
+from glob import glob
+import os
+from pathlib import Path
+import shutil
+from typing import Dict, List, Callable
+
+import cv2 as cv
+import numpy as np
+from python_speech_features import sigproc
+from scipy.io import wavfile
+from tqdm import tqdm
+
+from project_settings import project_path
+from toolbox.python_speech_features.misc import wave2spectrum_image
+
+
+area_code = 55
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--templates_dir",
+        default=(project_path / "data/early_media/{area_code}/templates".format(
+            area_code=area_code
+        )).as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--wav_dir",
+        default=(project_path / "data/early_media/{area_code}/wav".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+class AudioTemplateMatch(object):
+    def __init__(self,
+                 wave_to_spectrum: Callable,
+                 sample_rate: int = 8000,
+                 template_crop: float = 0.1,
+                 threshold: float = 0.01,
+                 ):
+        """
+        :param wave_to_spectrum: Callable, 传入 wave, np.ndarray, shape=(n,), 输出 spectrum, np.ndarray, shape=(time_steps, n_dim)
+        :param sample_rate:
+        :param template_crop:
+        :param threshold:
+        """
+        self.wave_to_spectrum = wave_to_spectrum
+        self.sample_rate = sample_rate
+        self.template_crop = template_crop
+        self.threshold = threshold
+
+        self.dim = 100
+
+        self.label2templates: Dict[str, List[Dict[str, np.ndarray]]] = None
+        self.max_template_width: int = None
+
+    def load_template(self, path: str):
+        filename_pattern = os.path.join(path, '*/*.wav')
+        filename_list = glob(filename_pattern)
+        label2templates = defaultdict(list)
+        max_template_width = 0
+
+        print('loading templates.')
+        for filename in tqdm(filename_list):
+            path, fn = os.path.split(filename)
+            root_path, label = os.path.split(path)
+
+            # wave, sample_rate = librosa.load(filename, sr=self.sample_rate)
+            sample_rate, wave = wavfile.read(filename)
+            if sample_rate != self.sample_rate:
+                raise AssertionError('expected sample rate: {}, instead of: {}'.format(self.sample_rate, sample_rate))
+            if wave.dtype != np.int16:
+                raise AssertionError('expected wave dtype np.int16, instead of: {}'.format(wave.dtype))
+
+            if wave.shape[0] < self.sample_rate:
+                raise AssertionError('wave.shape: {}'.format(wave.shape))
+
+            # dtype np.int16
+            max_wave_value = 32768.0
+            wave = wave / max_wave_value
+
+            template = self.wave_to_spectrum(wave)
+            template = template[:, :self.dim]
+
+            template_width, _ = template.shape
+            if template_width > max_template_width:
+                max_template_width = template_width
+            label2templates[label].append({
+                'filename': filename,
+                'template': template,
+            })
+
+        self.label2templates = label2templates
+        self.max_template_width = max_template_width
+        return label2templates, max_template_width
+
+    def template_match_by_wave(self, wave: np.ndarray):
+        # dtype np.int16
+        max_wave_value = 32768.0
+        wave = wave / max_wave_value
+
+        spectrum = self.wave_to_spectrum(wave)
+
+        spectrum = spectrum[:, :self.dim]
+        result = self.template_match_by_spectrum(spectrum)
+        return result
+
+    def template_match_by_spectrum(self, spectrum: np.ndarray):
+        result = self._shadow_template_match(spectrum)
+        return result
+
+    def _shadow_template_match(self, spectrum):
+        matches = list()
+
+        if spectrum.shape[0] < self.max_template_width:
+            return matches
+
+        for label, templates in self.label2templates.items():
+            for templ in templates:
+                filename = templ['filename']
+                template = templ['template']
+
+                tw, _ = template.shape[:2]
+                c = int(tw * self.template_crop)
+                template = template[c: -c]
+
+                tw, th = template.shape[:2]
+
+                shadow_m = 3
+                shadow_spect = spectrum[:, :shadow_m]
+                shadow_templ = template[:, :shadow_m]
+
+                sqdiff_normed = cv.matchTemplate(image=shadow_spect, templ=shadow_templ, method=cv.TM_SQDIFF_NORMED)
+                min_val, _, min_loc, _ = cv.minMaxLoc(sqdiff_normed)
+                # print(min_val, min_loc)
+                if min_val > self.threshold:
+                    continue
+
+                # master
+                _, x = min_loc
+                match_spectrum = spectrum[x:x+tw, :]
+                sqdiff_normed = cv.matchTemplate(image=match_spectrum, templ=template, method=cv.TM_SQDIFF_NORMED)
+
+                min_val, _, min_loc, _ = cv.minMaxLoc(sqdiff_normed)
+                # print(min_val, min_loc)
+                if min_val > self.threshold:
+                    continue
+
+                matches.append({
+                    'begin': x,
+                    'width': tw,
+                    'label': label,
+                    'filename': filename,
+                    'min_val': min_val,
+                })
+        return matches
+
+
+def main():
+    args = get_args()
+
+    templates_dir = Path(args.templates_dir)
+    wav_dir = Path(args.wav_dir)
+
+    def wave_to_spectrum(wave: np.ndarray):
+        spectrum = wave2spectrum_image(wave=wave, sample_rate=8000)
+        spectrum = np.array(spectrum, dtype=np.float32)
+        spectrum /= 255
+        return spectrum
+
+    audio_template_match = AudioTemplateMatch(
+        wave_to_spectrum=wave_to_spectrum,
+        sample_rate=8000,
+        template_crop=0.1,
+        threshold=0.007,
+    )
+    audio_template_match.load_template(path=args.templates_dir)
+
+    for filename in tqdm(wav_dir.glob("voice/*.wav")):
+        filename: Path = filename
+
+        sample_rate, signal = wavfile.read(filename)
+
+        if sample_rate != 8000:
+            print('sample rate not 8000, filename: {}'.format(filename))
+
+        matches = audio_template_match.template_match_by_wave(wave=signal)
+
+        if len(matches) == 0:
+            continue
+
+        labels = [match['label'] for match in matches]
+        labels_ = [label for label in labels if label not in ("music",)]
+
+        if len(set(labels_)) > 1:
+            print("超过两个模板类别被匹配，请检测是否匹配正确。")
+            print(filename)
+            for match in matches:
+                print(match)
+            continue
+
+        if len(labels_) == 0:
+            label = "music"
+        else:
+            label = labels_[0]
+
+        if filename.parts[-2] != label:
+            tgt = filename.parent.parent / label
+            os.makedirs(tgt, exist_ok=True)
+            try:
+                shutil.move(filename.as_posix(), tgt.as_posix())
+            except shutil.Error:
+                print(filename)
+                print(tgt)
+                continue
+
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/make_templates/step_4_batch_wav_split.py

@@ -0,0 +1,78 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from pathlib import Path
+
+import numpy as np
+from python_speech_features import sigproc
+from scipy.io import wavfile
+from tqdm import tqdm
+
+from project_settings import project_path
+
+
+area_code = 1
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--segmented_dir",
+        default=(project_path / "data/2s_wav/{area_code}".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--templates_dir",
+        default=(project_path / "data/early_media_template/{area_code}".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--wav_dir",
+        default=(project_path / "data/wav/{area_code}".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    parser.add_argument("--win_size", default=2.0, type=float)
+    parser.add_argument("--win_len", default=2.0, type=float)
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    segmented_dir = Path(args.segmented_dir)
+    templates_dir = Path(args.templates_dir)
+    wav_dir = Path(args.wav_dir)
+
+    segmented_dir.mkdir(parents=True, exist_ok=True)
+    templates_dir.mkdir(parents=True, exist_ok=True)
+
+    for filename in tqdm(wav_dir.glob("*/*.wav")):
+        # print(filename)
+
+        sample_rate, signal = wavfile.read(filename)
+        if len(signal) < args.win_size * sample_rate:
+            continue
+
+        frames = sigproc.framesig(
+            sig=signal,
+            frame_len=args.win_size * sample_rate,
+            frame_step=args.win_len * sample_rate,
+            # winfunc=np.hamming
+        )
+
+        for j, frame in enumerate(frames):
+            to_filename = segmented_dir / "{}_{}.wav".format(filename.stem, j)
+
+            frame = np.array(frame, dtype=np.int16)
+            wavfile.write(
+                filename=to_filename,
+                rate=sample_rate,
+                data=frame
+            )
+
+    return
+
+
+if __name__ == '__main__':
+    main()

project_settings.py

@@ -0,0 +1,12 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+from pathlib import Path
+
+
+project_path = os.path.abspath(os.path.dirname(__file__))
+project_path = Path(project_path)
+
+
+if __name__ == '__main__':
+    pass

requirements.txt

@@ -0,0 +1,18 @@
+setuptools_rust==1.1.2
+gradio==2.4.6
+opencv-contrib-python==3.4.10.37
+flask==2.0.2
+gevent==21.12.0
+werkzeug==2.0.2
+jsonschema==4.0.0
+numpy==1.19.5
+scipy==1.5.4
+torch==1.10.2
+tqdm==4.62.3
+python_speech_features==0.6
+scikit-learn==0.24.2
+requests==2.26.0
+gunicorn==20.1.0
+pandas==1.1.5
+xlrd==1.2.0
+openpyxl==3.0.9

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,149 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import copy
+from typing import List, Union
+import cv2 as cv
+
+
+def show_image(image, win_name='input image'):
+    # cv.namedWindow(win_name, cv.WINDOW_NORMAL)
+    cv.namedWindow(win_name, cv.WINDOW_AUTOSIZE)
+
+    cv.imshow(win_name, image)
+    cv.waitKey(0)
+    cv.destroyAllWindows()
+    return
+
+
+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/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