pdate

examples/download_wav/step_1_download_wav.py

@@ -0,0 +1,148 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from datetime import datetime
+from pathlib import Path
+
+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(
+        "--excel_file_dir",
+        default=(project_path / "examples/download_wav").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--start_date",
+        default="2022-04-10 00:00:00",
+        type=str
+    )
+    parser.add_argument(
+        "--end_date",
+        default="2026-04-21 00:00:00",
+        type=str
+    )
+    parser.add_argument(
+        "--output_dir",
+        default=(project_path / "data/calling/358/wav_2ch").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+excel_file_str = """
+AIAgent-CallLog-20250929100824.xlsx
+AIAgent-CallLog-20250929134959.xlsx
+AIAgent-CallLog-20250929135030.xlsx
+AIAgent-CallLog-20250929135052.xlsx
+AIAgent-CallLog-20250929135122.xlsx
+AIAgent-CallLog-20250929135134.xlsx
+AIAgent-CallLog-20250929135209.xlsx
+AIAgent-CallLog-20250929135219.xlsx
+AIAgent-CallLog-20250929135247.xlsx
+AIAgent-CallLog-20250929135300.xlsx
+AIAgent-CallLog-20250929135311.xlsx
+AIAgent-CallLog-20250929135335.xlsx
+AIAgent-CallLog-20250929135344.xlsx
+AIAgent-CallLog-20250929135355.xlsx
+AIAgent-CallLog-20250929135443.xlsx
+AIAgent-CallLog-20250929135452.xlsx
+AIAgent-CallLog-20250929135501.xlsx
+AIAgent-CallLog-20250929135537.xlsx
+AIAgent-CallLog-20250929135544.xlsx
+AIAgent-CallLog-20250929135554.xlsx
+AIAgent-CallLog-20250929135630.xlsx
+AIAgent-CallLog-20250929135701.xlsx
+AIAgent-CallLog-20250929135710.xlsx
+AIAgent-CallLog-20250929135716.xlsx
+AIAgent-CallLog-20250929135755.xlsx
+AIAgent-CallLog-20250929135800.xlsx
+AIAgent-CallLog-20250929135809.xlsx
+AIAgent-CallLog-20250929135842.xlsx
+AIAgent-CallLog-20250929135849.xlsx
+AIAgent-CallLog-20250929135858.xlsx
+AIAgent-CallLog-20250929135909.xlsx
+"""
+
+
+def main():
+    args = get_args()
+
+    format_str = "%Y-%m-%d %H:%M:%S"
+
+    start_date = datetime.strptime(args.start_date, format_str)
+    end_date = datetime.strptime(args.end_date, format_str)
+
+    excel_file_dir = Path(args.excel_file_dir)
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"start_date: {start_date}")
+    print(f"end_date: {end_date}")
+
+    # finished
+    finished = set()
+    for filename in output_dir.glob("*.wav"):
+        call_id = filename.stem
+        finished.add(call_id)
+
+    splits = excel_file_str.split("\n")
+    for row in splits:
+        name = str(row).strip()
+        if len(name) == 0:
+            continue
+        excel_file = excel_file_dir / name
+
+        df = pd.read_excel(excel_file.as_posix())
+        for i, row in tqdm(df.iterrows()):
+            call_date = row["Attempt time"]
+            call_id = row["Call ID"]
+            record_url = row["Recording file"]
+            if pd.isna(record_url):
+                continue
+
+            if call_id in finished:
+                continue
+            finished.add(call_id)
+
+            call_date = datetime.strptime(str(call_date), format_str)
+
+            if not start_date < call_date < end_date:
+                continue
+
+            call_date_str = call_date.strftime("%Y%m%d")
+            # record_url = f"https://phl-01.obs.ap-southeast-3.myhuaweicloud.com/{call_date_str}/21964/{call_id}.wav"
+            # record_url = f"https://nxai-hk-1259196162.cos.ap-hongkong.myqcloud.com/{call_date_str}/3101/{call_id}.wav"
+            # print(record_url)
+            try:
+                resp = requests.get(
+                    url=record_url,
+                )
+            except (TimeoutError, requests.exceptions.ConnectionError):
+                continue
+            except Exception as e:
+                print(e)
+                continue
+
+            if resp.status_code == 404:
+                continue
+            if resp.status_code != 200:
+                raise AssertionError("status_code: {}; text: {}".format(resp.status_code, resp.text))
+
+            filename = output_dir / "{}.wav".format(call_id)
+            with open(filename.as_posix(), "wb") as f:
+                f.write(resp.content)
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/download_wav/step_2_to_1ch.py

@@ -0,0 +1,79 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import os
+from pathlib import Path
+import time
+
+from scipy.io import wavfile
+from tqdm import tqdm
+
+from project_settings import project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--audio_dir",
+        default=(project_path / "data/calling/358/wav_2ch").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--output_dir",
+        default=(project_path / "data/calling/358/wav_1ch").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    audio_dir = Path(args.audio_dir)
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    finished = set()
+    for filename in tqdm(list(output_dir.glob("*.wav"))):
+        splits = filename.stem.split("_")
+        call_id = splits[3]
+        finished.add(call_id)
+    print(f"finished count: {len(finished)}")
+
+    for filename in tqdm(list(audio_dir.glob("*.wav"))):
+        call_id = filename.stem
+
+        if call_id in finished:
+            os.remove(filename.as_posix())
+            continue
+        finished.add(call_id)
+
+        try:
+            sample_rate, signal = wavfile.read(filename.as_posix())
+        except UnboundLocalError as error:
+            print(f"wavfile read failed. error type: {type(error)}, text: {str(error)}, filename: {filename.as_posix()}")
+            raise error
+        if sample_rate != 8000:
+            raise AssertionError
+
+        signal = signal[:, 0]
+
+        to_filename = output_dir / f"active_media_r_{call_id}_fi-FI_none.wav"
+        try:
+            wavfile.write(
+                to_filename.as_posix(),
+                sample_rate,
+                signal
+            )
+            os.remove(filename.as_posix())
+        except OSError as error:
+            print(f"wavfile write failed. error type: {type(error)}, text: {str(error)}, filename: {filename.as_posix()}")
+            raise error
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/download_wav/step_3_split_two_second_wav.py

@@ -0,0 +1,70 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from pathlib import Path
+import time
+
+from scipy.io import wavfile
+from tqdm import tqdm
+
+from project_settings import project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--audio_dir",
+        default=(project_path / "data/calling/358/wav_2ch").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--output_dir",
+        default=(project_path / "data/calling/358/wav_segmented").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--first_n_seconds",
+        default=8,
+        type=int
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    audio_dir = Path(args.audio_dir)
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    for filename in tqdm(list(audio_dir.glob("*.wav"))):
+        call_id = filename.stem
+        sample_rate, signal = wavfile.read(filename.as_posix())
+        if sample_rate != 8000:
+            raise AssertionError
+
+        signal = signal[:, 0]
+        signal_length = len(signal) - sample_rate * 2
+        if signal_length <= 0:
+            continue
+
+        for begin in range(0, signal_length, sample_rate * 2):
+            if begin >= sample_rate * args.first_n_seconds:
+                break
+            end = begin + sample_rate * 2
+            sub_signal = signal[begin: end]
+
+            ts = int(time.time() * 1000)
+            to_filename = output_dir / "{}_fi-FI_none_{}.wav".format(call_id, ts)
+            wavfile.write(
+                to_filename.as_posix(),
+                sample_rate,
+                sub_signal
+            )
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/download_wav/step_3_split_two_second_wav_by_vad.py

@@ -0,0 +1,101 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from pathlib import Path
+import time
+
+import numpy as np
+from scipy.io import wavfile
+from tqdm import tqdm
+
+from project_settings import project_path
+from toolbox.webrtcvad.vad import WebRTCVad
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--audio_dir",
+        default=(project_path / "data/calling/63/wav_2ch").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--output_dir",
+        default=(project_path / "data/calling/63/wav_segmented2").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--first_n_seconds",
+        default=10,
+        type=int
+    )
+    parser.add_argument(
+        "--sample_rate",
+        default=8000,
+        type=int
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    audio_dir = Path(args.audio_dir)
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    for filename in tqdm(list(audio_dir.glob("*.wav"))):
+        call_id = filename.stem
+        sample_rate, signal = wavfile.read(filename.as_posix())
+        if sample_rate != 8000:
+            raise AssertionError
+
+        signal = signal[:, 0]
+        signal = signal[:int(args.first_n_seconds * args.sample_rate)]
+
+        signal_length = len(signal) - sample_rate * 2
+        if signal_length <= 0:
+            continue
+
+        # vad
+        w_vad = WebRTCVad(sample_rate=args.sample_rate)
+        vad_segments = list()
+        segments = w_vad.vad(signal)
+        vad_segments += segments
+        segments = w_vad.last_vad_segments()
+        vad_segments += segments
+
+        for start, end in vad_segments:
+            if end - start < 0.01:
+                continue
+            start = max(0, start-0.4)
+            from_idx = int(start * sample_rate)
+            to_idx = int(end * sample_rate)
+            segment_signal = signal[from_idx: to_idx]
+            segment_signal_length = len(segment_signal)
+
+            min_inputs_length = 2 * sample_rate
+            for idx in range(0, segment_signal_length, min_inputs_length):
+                sub_signal = segment_signal[idx: idx + min_inputs_length]
+                sub_signal_length = len(sub_signal)
+                if sub_signal_length < min_inputs_length:
+                    pad_length = min_inputs_length - sub_signal_length
+                    # pad = np.zeros(shape=(pad_length,), dtype=np.int16)
+                    pad = 0 + 25 * np.random.randn(pad_length)
+                    pad = np.array(pad, dtype=np.int16)
+                    sub_signal = np.concatenate([sub_signal, pad])
+
+                ts = int(time.time() * 1000)
+                to_filename = output_dir / f"{call_id}_en-PH_kxob7p6suuye_{ts}.wav"
+                wavfile.write(
+                    filename=to_filename.as_posix(),
+                    rate=sample_rate,
+                    data=sub_signal
+                )
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/online_model_test/step_3_make_test.py

@@ -15,12 +15,12 @@ def get_args():
 
     parser.add_argument(
         "--src_dir",
-        default=r"D:\Users\tianx\HuggingDatasets\international_voice\data\calling\886",
+        default=r"D:\Users\tianx\HuggingDatasets\international_voice\data\calling\65\voicemail",
         type=str,
     )
     parser.add_argument(
         "--tgt_dir",
-        default=r"D:\Users\tianx\HuggingDatasets\international_voice\data\voice_test_examples\886\96",
+        default=r"D:\Users\tianx\HuggingDatasets\international_voice\data\voice_test_examples\65\95",
         type=str,
     )
     parser.add_argument(
@@ -37,6 +37,7 @@ def main():
 
     src_dir = Path(args.src_dir)
     tgt_dir = Path(args.tgt_dir)
+    tgt_dir.mkdir(parents=True, exist_ok=True)
 
     client = Client("http://10.75.27.247:7861/")
 

main.py

@@ -38,7 +38,7 @@ from project_settings import environment, project_path
 from toolbox.torch.utils.data.vocabulary import Vocabulary
 from tabs.cls_tab import get_cls_tab
 from tabs.split_tab import get_split_tab
-from tabs.voicemail_tab import get_voicemail_tab
+from tabs.event_tab import get_event_tab
 from tabs.shell_tab import get_shell_tab
 
 
@@ -135,7 +135,7 @@ def main():
                 examples_dir=args.examples_dir,
                 trained_model_dir=args.trained_model_dir,
             )
-            _ = get_voicemail_tab(
+            _ = get_event_tab(
                 examples_dir=args.examples_dir,
                 trained_model_dir=args.trained_model_dir,
             )

tabs/{voicemail_tab.py → event_tab.py}

@@ -1,7 +1,7 @@
 #!/usr/bin/python3
 # -*- coding: utf-8 -*-
 import json
-from functools import lru_cache
+from functools import lru_cache, partial
 from pathlib import Path
 import shutil
 import tempfile
@@ -43,9 +43,11 @@ def load_model(model_file: Path):
     return d
 
 
-def when_click_voicemail_button(audio_t,
-                                model_name: str,
-                                ground_true: str) -> Tuple[str, float]:
+def when_click_event_button(audio_t,
+                            model_name: str, target_label: str,
+                            win_size: float, win_step: float,
+                            max_duration: float
+                            ) -> Tuple[str, float]:
 
     sample_rate, signal = audio_t
 
@@ -58,16 +60,19 @@ def when_click_voicemail_button(audio_t,
     inputs = signal / (1 << 15)
     inputs = torch.tensor(inputs, dtype=torch.float32)
     inputs = torch.unsqueeze(inputs, dim=0)
+    # inputs shape: (1, num_samples)
+
+    win_size = int(win_size * sample_rate)
+    win_step = int(win_step * sample_rate)
+    max_duration = int(max_duration * sample_rate)
 
     outputs = list()
     with torch.no_grad():
-        for idx in range(0, 5):
-            begin = idx * int(sample_rate*2)
-            end = begin + int(sample_rate*2)
+        for begin in range(0, (max_duration-win_size+1), win_step):
+            end = begin + win_size
             sub_inputs = inputs[:, begin:end]
-            if sub_inputs.shape[-1] < sample_rate:
-                # raise AssertionError(f"audio duration less than: {sample_rate}")
-                continue
+            if sub_inputs.shape[-1] < win_size:
+                break
 
             logits = model.forward(sub_inputs)
             probs = torch.nn.functional.softmax(logits, dim=-1)
@@ -90,56 +95,82 @@ def when_click_voicemail_button(audio_t,
     return outputs
 
 
-def get_voicemail_tab(examples_dir: str, trained_model_dir: str):
-    voicemail_examples_dir = Path(examples_dir)
-    voicemail_trained_model_dir = Path(trained_model_dir)
+def when_model_name_change(model_name: str, event_trained_model_dir: Path):
+    m = load_model(
+        model_file=(event_trained_model_dir / f"{model_name}.zip")
+    )
+    token_to_index: dict = m["vocabulary"].get_token_to_index_vocabulary(namespace="labels")
+    label_choices = list(token_to_index.keys())
+
+    split_label = gr.Dropdown(choices=label_choices, value=label_choices[0], label="label")
+
+    return split_label
+
+
+def get_event_tab(examples_dir: str, trained_model_dir: str):
+    event_examples_dir = Path(examples_dir)
+    event_trained_model_dir = Path(trained_model_dir)
 
     # models
-    voicemail_model_choices = list()
-    for filename in voicemail_trained_model_dir.glob("*.zip"):
+    event_model_choices = list()
+    for filename in event_trained_model_dir.glob("*.zip"):
         model_name = filename.stem
         if model_name == "examples":
             continue
-        voicemail_model_choices.append(model_name)
-    model_choices = list(sorted(voicemail_model_choices))
+        event_model_choices.append(model_name)
+    model_choices = list(sorted(event_model_choices))
+
+    # model_labels_choices
+    m = load_model(
+        model_file=(event_trained_model_dir / f"{model_choices[0]}.zip")
+    )
+    token_to_index = m["vocabulary"].get_token_to_index_vocabulary(namespace="labels")
+    model_labels_choices = list(token_to_index.keys())
 
     # examples zip
-    voicemail_example_zip_file = voicemail_trained_model_dir / "examples.zip"
-    with zipfile.ZipFile(voicemail_example_zip_file.as_posix(), "r") as f_zip:
-        out_root = voicemail_examples_dir
+    event_example_zip_file = event_trained_model_dir / "examples.zip"
+    with zipfile.ZipFile(event_example_zip_file.as_posix(), "r") as f_zip:
+        out_root = event_examples_dir
         if out_root.exists():
             shutil.rmtree(out_root.as_posix())
         out_root.mkdir(parents=True, exist_ok=True)
         f_zip.extractall(path=out_root)
 
     # examples
-    voicemail_examples = list()
-    for filename in voicemail_examples_dir.glob("**/*/*.wav"):
+    event_examples = list()
+    for filename in event_examples_dir.glob("**/*/*.wav"):
         label = filename.parts[-2]
-        voicemail_examples.append([
+        event_examples.append([
             filename.as_posix(),
             model_choices[0],
             label
         ])
 
-    with gr.TabItem("voicemail"):
+    with gr.TabItem("event"):
         with gr.Row():
             with gr.Column(scale=3):
-                voicemail_audio = gr.Audio(label="audio")
+                event_audio = gr.Audio(label="audio")
                 with gr.Row():
-                    with gr.Column(scale=3):
-                        voicemail_model_name = gr.Dropdown(choices=model_choices, value=model_choices[0], label="model_name")
-                    with gr.Column(scale=3):
-                        voicemail_ground_true = gr.Textbox(label="ground_true")
-
-                voicemail_button = gr.Button("run", variant="primary")
+                    event_model_name = gr.Dropdown(choices=model_choices, value=model_choices[0], label="model_name")
+                    event_label = gr.Dropdown(choices=model_labels_choices, value=model_labels_choices[0], label="label")
+                with gr.Row():
+                    event_win_size = gr.Number(value=2.0, minimum=0, maximum=5, step=0.05, label="win_size")
+                    event_win_step = gr.Number(value=2.0, minimum=0, maximum=5, step=0.05, label="win_step")
+                    event_max_duration = gr.Number(value=8, minimum=0, maximum=15, step=1, label="max_duration")
+                event_button = gr.Button("run", variant="primary")
             with gr.Column(scale=3):
-                voicemail_outputs = gr.Textbox(label="outputs")
+                event_outputs = gr.Textbox(label="outputs")
+
+        event_model_name.change(
+            partial(when_model_name_change, event_trained_model_dir=event_trained_model_dir),
+            inputs=[event_model_name],
+            outputs=[event_label],
+        )
 
-        voicemail_button.click(
-            when_click_voicemail_button,
-            inputs=[voicemail_audio, voicemail_model_name, voicemail_ground_true],
-            outputs=[voicemail_outputs],
+        event_button.click(
+            when_click_event_button,
+            inputs=[event_audio, event_model_name, event_label, event_win_size, event_win_step, event_max_duration],
+            outputs=[event_outputs],
         )
 
     return locals()