update

.gitignore

@@ -1,4 +1,5 @@
 
+.gradio/
 .git/
 .idea/
 

examples/jky_gender/step_1.py

@@ -1,53 +0,0 @@
-#!/usr/bin/python3
-# -*- coding: utf-8 -*-
-"""
-https://arxiv.org/abs/2306.16962
-
-https://huggingface.co/audeering/wav2vec2-large-robust-24-ft-age-gender
-"""
-import argparse
-
-import pandas as pd
-import torch
-import torch.nn as nn
-import librosa
-from transformers import Wav2Vec2Processor
-from transformers.models.wav2vec2.modeling_wav2vec2 import Wav2Vec2Model, Wav2Vec2PreTrainedModel
-
-from project_settings import project_path
-
-
-def get_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model_path",
-        # default=(project_path / "pretrained_models/wav2vec2-large-robust-6-ft-age-gender").as_posix(),
-        default=(project_path / "pretrained_models/wav2vec2-large-robust-6-ft-age-gender").as_posix(),
-        type=str,
-    )
-    parser.add_argument(
-        "--task_file",
-        default=(project_path / "examples/jky_gender/task_8.27开始+日本GMP营销永久任务.xlsx").as_posix(),
-        type=str,
-    )
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = get_args()
-
-    df = pd.read_excel(args.task_file)
-    for i, row in df.iterrows():
-        task_name = row["任务名称"]
-        bot_name = row["话术模版名称"]
-        call_id = row["通话ID"]
-        duration = row["通话时长"]
-        intent_desc = row["意向标签"]
-        record_url = row["录音地址"]
-
-    return
-
-
-if __name__ == "__main__":
-    main()

examples/jky_gender/step_1_predict_by_task.py

@@ -0,0 +1,242 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://arxiv.org/abs/2306.16962
+
+https://huggingface.co/audeering/wav2vec2-large-robust-24-ft-age-gender
+
+查看GPU
+nvidia-smi
+watch -n 1 -d nvidia-smi
+"""
+import argparse
+import json
+import logging
+import shutil
+from pathlib import Path
+from urllib.parse import urlparse
+
+import numpy as np
+from gradio_client import Client, handle_file
+import pandas as pd
+import requests
+from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_fixed
+
+import log
+from project_settings import project_path, temp_directory, time_zone_info
+
+log.setup_stream(tz_info=time_zone_info)
+
+logger = logging.getLogger("main")
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--task_file",
+        default=(project_path / "examples/jky_gender/task_8.27开始+日本GMP营销永久任务.xlsx").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--raw_audio_dir",
+        default=(temp_directory / "raw_audio").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--sub_audio_dir",
+        default=(temp_directory / "sub_audio").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--concat_audio_dir",
+        default=(temp_directory / "concat_audio").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--output_file",
+        default=(temp_directory / "age_and_gender/predict.jsonl").as_posix(),
+        type=str,
+    )
+    args = parser.parse_args()
+    return args
+
+
+def get_audio_by_url(url: str, audio_dir: str) -> str:
+    audio_dir = Path(audio_dir)
+    audio_dir.mkdir(parents=True, exist_ok=True)
+
+    p = urlparse(url)
+    name = Path(p.path).name
+
+    filename = audio_dir / name
+    if not filename.exists():
+        response = requests.get(url)
+        with open(filename, "wb") as f:
+            f.write(response.content)
+
+    return filename.as_posix()
+
+
+def retry_call(fn, *args, **kwargs):
+    @retry(
+        wait=wait_fixed(10),
+        stop=stop_after_attempt(3),
+        before_sleep=before_sleep_log(logger, logging.ERROR),
+    )
+    def wrapped():
+        return fn(*args, **kwargs)
+    return wrapped()
+
+
+def main():
+    args = get_args()
+
+    raw_audio_dir = Path(args.raw_audio_dir)
+    raw_audio_dir.mkdir(parents=True, exist_ok=True)
+    sub_audio_dir = Path(args.sub_audio_dir)
+    sub_audio_dir.mkdir(parents=True, exist_ok=True)
+    concat_audio_dir = Path(args.concat_audio_dir)
+    concat_audio_dir.mkdir(parents=True, exist_ok=True)
+    output_file = Path(args.output_file)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # audio edit
+    client1 = Client("http://10.75.27.247:7861/")
+
+    # cc_audio_8
+    client2 = Client("http://10.75.27.247:7864/")
+
+    # age and gender
+    client3 = Client("http://10.75.27.247:7863/")
+
+    # finished
+    finished = set()
+    if output_file.exists():
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                call_id = row["call_id"]
+                finished.add(call_id)
+    logger.info(f"finished count: {len(finished)}")
+
+    df = pd.read_excel(args.task_file)
+    with open(output_file.as_posix(), "a+", encoding="utf-8") as f:
+        for i, row in df.iterrows():
+            task_name = row["任务名称"]
+            bot_name = row["话术模版名称"]
+            call_id = row["通话ID"]
+            duration = row["通话时长(秒)"]
+            intent_desc = row["意向标签"]
+            record_url = row["录音地址"]
+            if pd.isna(record_url):
+                continue
+            if intent_desc in ["语音信箱"]:
+                continue
+
+            # download url
+            filename: str = retry_call(get_audio_by_url, record_url,  audio_dir=raw_audio_dir.as_posix())
+            logger.info(f"finish download: {filename}")
+
+            filename, _, _, _ = retry_call(
+                client1.predict,
+                audio_t=handle_file(filename),
+                to_sample_rate=8000,
+                sample_width=2,
+                channels="0",
+                engine="librosa",
+                api_name="/when_click_audio_convert"
+            )
+            logger.info(f"finish convert: {filename}")
+
+            sub_audio_dataset = retry_call(
+                client2.predict,
+                audio_t=handle_file(filename),
+                model_name="sound-8-ch32",
+                label="voice",
+                win_size=2,
+                win_step=0.25,
+                n_erode=2,
+                n_dilate=2,
+                api_name="/when_click_split_button"
+            )
+            sub_audio_dataset = sub_audio_dataset["samples"]
+            logger.info(f"finish sub_audio_dataset, count: {len(sub_audio_dataset)}")
+            if len(sub_audio_dataset) == 0:
+                row = {
+                    "task_name": task_name,
+                    "bot_name": bot_name,
+                    "call_id": call_id,
+                    "duration": duration,
+                    "intent_desc": intent_desc,
+                    "record_url": record_url,
+                    "label": "silence",
+                    "prob": 1,
+                }
+                row = json.dumps(row, ensure_ascii=False)
+                f.write(f"{row}\n")
+                f.flush()
+                continue
+
+            sub_audio_dir_ = sub_audio_dir / call_id
+            sub_audio_dir_.mkdir(parents=True, exist_ok=True)
+            sub_filename_list = list()
+            for idx in range(len(sub_audio_dataset)):
+                sub_audio, _ = retry_call(
+                    client2.predict,
+                    x=idx,
+                    api_name="/lambda"
+                )
+                sub_filename = (sub_audio_dir_ / f"{call_id}_{idx}.wav").as_posix()
+                shutil.move(sub_audio, sub_filename)
+                sub_filename_list.append(sub_filename)
+            logger.info(f"finish sub_filename_list: {sub_filename_list}")
+
+            concat_audio, _ = retry_call(
+                client1.predict,
+                files=[handle_file(item) for item in sub_filename_list],
+                api_name="/when_click_concat_audio"
+            )
+            concat_filename = (concat_audio_dir / f"{call_id}.wav").as_posix()
+            shutil.move(concat_audio, concat_filename)
+            logger.info(f"finish concat_filename: {concat_filename}")
+
+            logger.info(f"start get_age_and_gender: {concat_filename}")
+            js = retry_call(
+                client3.predict,
+                audio_t=handle_file(concat_filename),
+                engine="audeering-6-ft",
+                api_name="/when_click_get_age_and_gender_button"
+            )
+            js = json.loads(js)
+            logger.info(f"finish get_age_and_gender")
+
+            labels = ["female", "male", "child"]
+            probs = list()
+            for label in labels:
+                prob = js[label]
+                probs.append(prob)
+
+            index = np.argmax(probs)
+            label = labels[index]
+            prob = probs[index]
+            logger.info(f"finally predict label: {label}, prob: {prob}")
+
+            row = {
+                "task_name": task_name,
+                "bot_name": bot_name,
+                "call_id": call_id,
+                "duration": duration,
+                "intent_desc": intent_desc,
+                "record_url": record_url,
+                "label": label,
+                "prob": prob,
+            }
+            row = json.dumps(row, ensure_ascii=False)
+            f.write(f"{row}\n")
+            f.flush()
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/jky_gender/step_2_predict_by_concat_audio.py

@@ -0,0 +1,134 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://arxiv.org/abs/2306.16962
+
+https://huggingface.co/audeering/wav2vec2-large-robust-24-ft-age-gender
+
+查看GPU
+nvidia-smi
+watch -n 1 -d nvidia-smi
+"""
+import argparse
+import json
+import logging
+import shutil
+from pathlib import Path
+from urllib.parse import urlparse
+
+import numpy as np
+from gradio_client import Client, handle_file
+import pandas as pd
+import requests
+from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_fixed
+
+import log
+from project_settings import project_path, temp_directory, time_zone_info
+
+log.setup_stream(tz_info=time_zone_info)
+
+logger = logging.getLogger("main")
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--concat_audio_dir",
+        default=(temp_directory / "concat_audio").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--output_file",
+        default=(temp_directory / "age_and_gender/predict-audeering-24-ft.jsonl").as_posix(),
+        type=str,
+    )
+    args = parser.parse_args()
+    return args
+
+
+def get_audio_by_url(url: str, audio_dir: str) -> str:
+    audio_dir = Path(audio_dir)
+    audio_dir.mkdir(parents=True, exist_ok=True)
+
+    p = urlparse(url)
+    name = Path(p.path).name
+
+    filename = audio_dir / name
+    if not filename.exists():
+        response = requests.get(url)
+        with open(filename, "wb") as f:
+            f.write(response.content)
+
+    return filename.as_posix()
+
+
+def retry_call(fn, *args, **kwargs):
+    @retry(
+        wait=wait_fixed(10),
+        stop=stop_after_attempt(3),
+        before_sleep=before_sleep_log(logger, logging.ERROR),
+    )
+    def wrapped():
+        return fn(*args, **kwargs)
+    return wrapped()
+
+
+def main():
+    args = get_args()
+
+    concat_audio_dir = Path(args.concat_audio_dir)
+    output_file = Path(args.output_file)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # age and gender
+    client3 = Client("http://10.75.27.247:7863/")
+
+    # finished
+    finished = set()
+    if output_file.exists():
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                call_id = row["call_id"]
+                finished.add(call_id)
+    logger.info(f"finished count: {len(finished)}")
+
+    with open(output_file.as_posix(), "a+", encoding="utf-8") as f:
+        for filename in concat_audio_dir.glob("*.wav"):
+            call_id = filename.stem
+
+            logger.info(f"start get_age_and_gender: {filename.as_posix()}")
+            js = retry_call(
+                client3.predict,
+                audio_t=handle_file(filename.as_posix()),
+                engine="audeering-24-ft",
+                api_name="/when_click_get_age_and_gender_button"
+            )
+            js = json.loads(js)
+            logger.info(f"finish get_age_and_gender")
+
+            labels = ["female", "male", "child"]
+            probs = list()
+            for label in labels:
+                prob = js[label]
+                probs.append(prob)
+
+            index = np.argmax(probs)
+            label = labels[index]
+            prob = probs[index]
+            logger.info(f"finally predict label: {label}, prob: {prob}")
+
+            row = {
+                "call_id": call_id,
+                "label": label,
+                "prob": prob,
+            }
+            row = json.dumps(row, ensure_ascii=False)
+            f.write(f"{row}\n")
+            f.flush()
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/jky_gender/step_3_make_excel.py

@@ -0,0 +1,68 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://arxiv.org/abs/2306.16962
+
+https://huggingface.co/audeering/wav2vec2-large-robust-24-ft-age-gender
+
+查看GPU
+nvidia-smi
+watch -n 1 -d nvidia-smi
+"""
+import argparse
+import json
+import logging
+import shutil
+from pathlib import Path
+from urllib.parse import urlparse
+
+import numpy as np
+from gradio_client import Client, handle_file
+import pandas as pd
+import requests
+from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_fixed
+
+import log
+from project_settings import project_path, temp_directory, time_zone_info
+
+log.setup_stream(tz_info=time_zone_info)
+
+logger = logging.getLogger("main")
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--jsonl_file",
+        default=(temp_directory / "age_and_gender/predict-audeering-24-ft.jsonl").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--output_file",
+        default=(temp_directory / "age_and_gender/predict-audeering-24-ft.xlsx").as_posix(),
+        type=str,
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    jsonl_file = Path(args.jsonl_file)
+    output_file = Path(args.output_file)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    result = list()
+    with open(jsonl_file.as_posix(), "r", encoding="utf-8") as fin:
+        for row in fin:
+            row = json.loads(row)
+            result.append(row)
+
+    result = pd.DataFrame(result)
+    result.to_excel(output_file.as_posix(), index=False)
+    return
+
+
+if __name__ == "__main__":
+    main()

log.py

@@ -1,16 +1,67 @@
 #!/usr/bin/python3
 # -*- coding: utf-8 -*-
+from datetime import datetime
 import logging
 from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
 import os
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
 
 
-def setup_size_rotating(log_directory: str):
-    fmt = "%(asctime)s - %(name)s - %(levelname)s  %(filename)s:%(lineno)d >  %(message)s"
+def get_converter(tz_info: str = "Asia/Shanghai"):
+    def converter(timestamp):
+        dt = datetime.fromtimestamp(timestamp, ZoneInfo(tz_info))
+        result = dt.timetuple()
+        return result
+    return converter
+
+
+def setup_stream(tz_info: str = "Asia/Shanghai"):
+    fmt = "%(asctime)s|%(name)s|%(levelname)s|%(filename)s|%(lineno)d|%(message)s"
+
+    formatter = logging.Formatter(
+        fmt=fmt,
+        datefmt="%Y-%m-%d %H:%M:%S %z"
+    )
+    formatter.converter = get_converter(tz_info)
 
     stream_handler = logging.StreamHandler()
     stream_handler.setLevel(logging.INFO)
-    stream_handler.setFormatter(logging.Formatter(fmt))
+    stream_handler.setFormatter(formatter)
+
+    # main
+    main_logger = logging.getLogger("main")
+    main_logger.addHandler(stream_handler)
+
+    # http
+    http_logger = logging.getLogger("http")
+    http_logger.addHandler(stream_handler)
+
+    # api
+    api_logger = logging.getLogger("api")
+    api_logger.addHandler(stream_handler)
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        datefmt="%a, %d %b %Y %H:%M:%S",
+        handlers=[
+
+        ]
+    )
+    return
+
+
+def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
+    fmt = "%(asctime)s|%(name)s|%(levelname)s|%(filename)s|%(lineno)d|%(message)s"
+
+    formatter = logging.Formatter(
+        fmt=fmt,
+        datefmt="%Y-%m-%d %H:%M:%S %z"
+    )
+    formatter.converter = get_converter(tz_info)
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    stream_handler.setFormatter(formatter)
 
     # main
     main_logger = logging.getLogger("main")
@@ -22,11 +73,12 @@ def setup_size_rotating(log_directory: str):
         backupCount=2,
     )
     main_info_file_handler.setLevel(logging.INFO)
-    main_info_file_handler.setFormatter(logging.Formatter(fmt))
+    main_info_file_handler.setFormatter(formatter)
     main_logger.addHandler(main_info_file_handler)
 
     # http
     http_logger = logging.getLogger("http")
+    http_logger.addHandler(stream_handler)
     http_file_handler = RotatingFileHandler(
         filename=os.path.join(log_directory, "http.log"),
         maxBytes=100*1024*1024,  # 100MB
@@ -34,11 +86,12 @@ def setup_size_rotating(log_directory: str):
         backupCount=2,
     )
     http_file_handler.setLevel(logging.DEBUG)
-    http_file_handler.setFormatter(logging.Formatter(fmt))
+    http_file_handler.setFormatter(formatter)
     http_logger.addHandler(http_file_handler)
 
     # api
     api_logger = logging.getLogger("api")
+    api_logger.addHandler(stream_handler)
     api_file_handler = RotatingFileHandler(
         filename=os.path.join(log_directory, "api.log"),
         maxBytes=10*1024*1024,  # 10MB
@@ -46,22 +99,9 @@ def setup_size_rotating(log_directory: str):
         backupCount=2,
     )
     api_file_handler.setLevel(logging.DEBUG)
-    api_file_handler.setFormatter(logging.Formatter(fmt))
+    api_file_handler.setFormatter(formatter)
     api_logger.addHandler(api_file_handler)
 
-    # toolbox
-    toolbox_logger = logging.getLogger("toolbox")
-    toolbox_logger.addHandler(stream_handler)
-    toolbox_file_handler = RotatingFileHandler(
-        filename=os.path.join(log_directory, "toolbox.log"),
-        maxBytes=10*1024*1024,  # 10MB
-        encoding="utf-8",
-        backupCount=2,
-    )
-    toolbox_file_handler.setLevel(logging.DEBUG)
-    toolbox_file_handler.setFormatter(logging.Formatter(fmt))
-    toolbox_logger.addHandler(toolbox_file_handler)
-
     # alarm
     alarm_logger = logging.getLogger("alarm")
     alarm_file_handler = RotatingFileHandler(
@@ -71,7 +111,7 @@ def setup_size_rotating(log_directory: str):
         backupCount=2,
     )
     alarm_file_handler.setLevel(logging.DEBUG)
-    alarm_file_handler.setFormatter(logging.Formatter(fmt))
+    alarm_file_handler.setFormatter(formatter)
     alarm_logger.addHandler(alarm_file_handler)
 
     debug_file_handler = RotatingFileHandler(
@@ -81,7 +121,7 @@ def setup_size_rotating(log_directory: str):
         backupCount=2,
     )
     debug_file_handler.setLevel(logging.DEBUG)
-    debug_file_handler.setFormatter(logging.Formatter(fmt))
+    debug_file_handler.setFormatter(formatter)
 
     info_file_handler = RotatingFileHandler(
         filename=os.path.join(log_directory, "info.log"),
@@ -90,7 +130,7 @@ def setup_size_rotating(log_directory: str):
         backupCount=2,
     )
     info_file_handler.setLevel(logging.INFO)
-    info_file_handler.setFormatter(logging.Formatter(fmt))
+    info_file_handler.setFormatter(formatter)
 
     error_file_handler = RotatingFileHandler(
         filename=os.path.join(log_directory, "error.log"),
@@ -99,7 +139,7 @@ def setup_size_rotating(log_directory: str):
         backupCount=2,
     )
     error_file_handler.setLevel(logging.ERROR)
-    error_file_handler.setFormatter(logging.Formatter(fmt))
+    error_file_handler.setFormatter(formatter)
 
     logging.basicConfig(
         level=logging.DEBUG,
@@ -159,18 +199,6 @@ def setup_time_rotating(log_directory: str):
     api_file_handler.setFormatter(logging.Formatter(fmt))
     api_logger.addHandler(api_file_handler)
 
-    # toolbox
-    toolbox_logger = logging.getLogger("toolbox")
-    toolbox_file_handler = RotatingFileHandler(
-        filename=os.path.join(log_directory, "toolbox.log"),
-        maxBytes=10*1024*1024,  # 10MB
-        encoding="utf-8",
-        backupCount=2,
-    )
-    toolbox_file_handler.setLevel(logging.DEBUG)
-    toolbox_file_handler.setFormatter(logging.Formatter(fmt))
-    toolbox_logger.addHandler(toolbox_file_handler)
-
     # alarm
     alarm_logger = logging.getLogger("alarm")
     alarm_file_handler = TimedRotatingFileHandler(

main.py

@@ -8,8 +8,7 @@ docker run -itd \
 --restart=always \
 --network host \
 -e server_port=7865 \
-denoise:v20250828_1030 /bin/bash
-
+speech_age_and_gender:v20250828_1030 /bin/bash
 
 docker run -itd \
 --name speech_age_and_gender_7863 \
@@ -17,20 +16,9 @@ docker run -itd \
 --gpus all \
 --privileged \
 --ipc=host \
--v /data/tianxing/HuggingDatasets/nx_noise/data:/data/tianxing/HuggingDatasets/nx_noise/data \
--v /data/tianxing/PycharmProjects/cc_vad:/data/tianxing/PycharmProjects/cc_vad \
 python:3.12 /bin/bash
 
-
-docker run -itd \
---name speech_age_and_gender_7863 \
---network host \
---gpus all \
---privileged \
---ipc=host \
-python:3.12 /bin/bash
-
-
+nohup python3 main.py --server_port 7863 &
 """
 import argparse
 from functools import lru_cache
@@ -51,6 +39,7 @@ import log
 from project_settings import environment, project_path, log_directory
 from toolbox.os.command import Command
 from toolbox.age_and_gender.models.audeering import AudeeringModel
+from toolbox.age_and_gender.models.common_voice import CommonVoiceGenderModel
 
 log.setup_size_rotating(log_directory=log_directory)
 
@@ -109,6 +98,15 @@ age_and_gender_model_map = {
         },
         "sample_rate": 16000,
     },
+    "common_voice_gender_detection": {
+        "infer_cls": CommonVoiceGenderModel,
+        "kwargs": {
+            "model_path":
+                (project_path / "pretrained_models/Common-Voice-Gender-Detection").as_posix()
+                if platform.system() == "Windows" else "prithivMLmods/Common-Voice-Gender-Detection",
+        },
+        "sample_rate": 16000,
+    },
 }
 
 
@@ -139,7 +137,6 @@ def when_click_get_age_and_gender_button(audio_t, engine: str):
 
         infer_engine = load_get_age_and_gender_model(infer_cls=infer_cls, **kwargs)
 
-
         time_begin = time.time()
         age_and_gender = infer_engine.__call__(signal, sample_rate)
         time_cost = time.time() - time_begin

project_settings.py

@@ -9,9 +9,14 @@ from toolbox.os.environment import EnvironmentManager
 project_path = os.path.abspath(os.path.dirname(__file__))
 project_path = Path(project_path)
 
+time_zone_info = "Asia/Shanghai"
+
 log_directory = project_path / "logs"
 log_directory.mkdir(parents=True, exist_ok=True)
 
+temp_directory = project_path / "temp"
+temp_directory.mkdir(parents=True, exist_ok=True)
+
 environment = EnvironmentManager(
     path=os.path.join(project_path, "dotenv"),
     env=os.environ.get("environment", "dev"),

requirements.txt

@@ -7,3 +7,4 @@ librosa
 python-dotenv
 pandas
 openpyxl
+tenacity

toolbox/age_and_gender/models/common_voice.py

@@ -0,0 +1,55 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+
+import numpy as np
+import torch
+import torch.nn as nn
+import librosa
+from transformers import Wav2Vec2Processor
+from transformers.models.wav2vec2.modeling_wav2vec2 import Wav2Vec2Model, Wav2Vec2PreTrainedModel
+from transformers import Wav2Vec2ForSequenceClassification, Wav2Vec2FeatureExtractor
+
+from project_settings import project_path
+
+
+class CommonVoiceGenderModel(object):
+    def __init__(self, model_path: str):
+        self.model_path = model_path
+
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        processor = Wav2Vec2FeatureExtractor.from_pretrained(self.model_path)
+        model = Wav2Vec2ForSequenceClassification.from_pretrained(self.model_path).to(device)
+        model.eval()
+
+        self.device = device
+        self.processor = processor
+        self.model = model
+
+    def predict(self, signal: np.ndarray, sample_rate: int) -> dict:
+        y = self.processor.__call__(signal, sampling_rate=sample_rate)
+        print(f"y: {y}")
+        y = y["input_values"][0]
+        y = y.reshape(1, -1)
+        y = torch.from_numpy(y).to(self.device)
+
+        _, age, gender = self.model.forward(y)
+
+        gender = gender.detach().cpu().numpy().tolist()
+        gender = gender[0]
+
+        result = {
+            "age": round(age, 4),
+            "female": round(gender[0], 4),
+            "male": round(gender[1], 4),
+            "child": round(gender[2], 4),
+        }
+        return result
+
+    def __call__(self, *args, **kwargs):
+        return self.predict(*args, **kwargs)
+
+
+if __name__ == "__main__":
+    pass