enlarge seq_len to 256

SenseVoiceAx.py

@@ -26,49 +26,33 @@ def sequence_mask(lengths, maxlen=None, dtype=np.float32):
     # 返回指定数据类型的掩码
     return mask.astype(dtype)[None, ...]
     
-def unique_consecutive_np(x, dim=None, return_inverse=False, return_counts=False):
-    if dim is None:
-        # 默认情况，展平后去重
-        x_flat = x.ravel()
-        mask = np.concatenate(([True], x_flat[1:] != x_flat[:-1]))
-        unique_data = x_flat[mask]
-    else:
-        # 沿着指定维度去重
-        axis = dim if dim >= 0 else x.ndim + dim
-        if axis >= x.ndim:
-            raise ValueError(f"dim {dim} is out of range for array of dimension {x.ndim}")
-        
-        # 使用 np.diff 检查相邻元素是否相同
-        mask = np.ones(x.shape[axis], dtype=bool)
-        if x.shape[axis] > 1:
-            # 比较当前元素和前一个元素是否不同
-            diff = np.diff(x, axis=axis)
-            mask[1:] = np.any(diff != 0, axis=tuple(range(diff.ndim))[axis:])
-        
-        # 使用 mask 索引提取唯一元素
-        unique_data = np.take(x, np.where(mask)[0], axis=axis)
-    
-    # 处理 return_inverse 和 return_counts
-    results = (unique_data,)
-    
-    if return_inverse:
-        if dim is None:
-            inv_idx = np.cumsum(mask) - 1
-        else:
-            inv_idx = np.cumsum(mask) - 1
-            # 需要调整形状以匹配输入
-            inv_idx = np.expand_dims(inv_idx, axis=axis)
-            inv_idx = np.broadcast_to(inv_idx, x.shape)
-        results += (inv_idx,)
-    
-    if return_counts:
-        if dim is None:
-            counts = np.diff(np.where(np.concatenate((mask, [True])))[0])
-        else:
-            counts = np.diff(np.where(np.concatenate((mask, [True])))[0])
-        results += (counts,)
+def unique_consecutive_np(arr):
+    """
+    找出数组中连续的唯一值，模拟 torch.unique_consecutive(yseq, dim=-1)
+    
+    参数:
+    arr: 一维numpy数组
+    
+    返回:
+    unique_values: 去除连续重复值后的数组
+    """
+    if len(arr) == 0:
+        return np.array([])
+    
+    if len(arr) == 1:
+        return arr.copy()
+    
+    # 找出变化的位置
+    diff = np.diff(arr)
+    change_positions = np.where(diff != 0)[0] + 1
     
-    return results[0] if len(results) == 1 else results
+    # 添加起始位置
+    start_positions = np.concatenate(([0], change_positions))
+    
+    # 获取唯一值（每个连续段的第一个值）
+    unique_values = arr[start_positions]
+    
+    return unique_values
 
 
 def longest_common_suffix_prefix_with_tolerance(
@@ -100,7 +84,7 @@ def longest_common_suffix_prefix_with_tolerance(
     return 0
 
 class SenseVoiceAx:
-    def __init__(self, model_path, max_len=68, language="auto", use_itn=True, tokenizer=None):
+    def __init__(self, model_path, max_len=256, language="auto", use_itn=True, tokenizer=None):
         model_path_root = os.path.join(os.path.dirname(model_path), "..")
         embedding_root = os.path.join(model_path_root, "embeddings")
         self.frontend = WavFrontend(cmvn_file=f"{model_path_root}/am.mvn",
@@ -125,12 +109,29 @@ class SenseVoiceAx:
         self.emo_dict = {"unk": 25009, "happy": 25001, "sad": 25002, "angry": 25003, "neutral": 25004}
 
         self.position_encoding = np.load(f"{embedding_root}/position_encoding.npy")
-        language_query = np.load(f"{embedding_root}/{language}.npy")
-        textnorm_query = np.load(f"{embedding_root}/withitn.npy") if use_itn else np.load(f"{embedding_root}/woitn.npy")
-        event_emo_query = np.load(f"{embedding_root}/event_emo.npy")
-        self.input_query = np.concatenate((textnorm_query, language_query, event_emo_query), axis=1)
+        self.language_query = np.load(f"{embedding_root}/{language}.npy")
+        self.textnorm_query = np.load(f"{embedding_root}/withitn.npy") if use_itn else np.load(f"{embedding_root}/woitn.npy")
+        self.event_emo_query = np.load(f"{embedding_root}/event_emo.npy")
+        self.input_query = np.concatenate((self.textnorm_query, self.language_query, self.event_emo_query), axis=1)
         self.query_num = self.input_query.shape[1]
 
+        self.model_path_root = model_path_root
+        self.embedding_root = embedding_root
+        self.language = language
+
+    @property
+    def language_options(self):
+        return list(self.lid_dict.keys())
+    
+    @property
+    def textnorm_options(self):
+        return list(self.textnorm_dict.keys())
+    
+    def choose_language(self, language):
+        self.language_query = np.load(f"{self.embedding_root}/{language}.npy")
+        self.input_query = np.concatenate((self.textnorm_query, self.language_query, self.event_emo_query), axis=1)
+        self.language = language
+
     def load_data(self, filepath: str) -> np.ndarray:
         waveform, _ = librosa.load(filepath, sr=self.sample_rate)
         return waveform.flatten()
@@ -165,7 +166,7 @@ class SenseVoiceAx:
         yseq = np.argmax(x, axis=-1)
 
         # 去除连续重复元素
-        yseq = unique_consecutive_np(yseq, dim=-1)
+        yseq = unique_consecutive_np(yseq)
 
         # 创建掩码并过滤 blank_id
         mask = yseq != self.blank_id
@@ -173,14 +174,16 @@ class SenseVoiceAx:
 
         return token_int
     
-    def infer_waveform(self, waveform: np.ndarray):
+    def infer_waveform(self, waveform: np.ndarray, language="auto"):
+        if language != self.language:
+            self.choose_language(language)
+
         feat, feat_len = self.preprocess(waveform)
 
         slice_len = self.max_len - self.query_num
         slice_num = int(np.ceil(feat.shape[1] / slice_len))
 
         asr_res = []
-        prev_token_int = None
         for i in range(slice_num):
             if i == 0:
                 sub_feat = feat[:, i*slice_len:(i+1)*slice_len, :]
@@ -205,20 +208,14 @@ class SenseVoiceAx:
 
             token_int = self.postprocess(ctc_logits, encoder_out_lens)
 
-            # common prefix
-            if self.padding > 0 and prev_token_int is not None:
-                # prefix_len = common_prefix_len(prev_token_int, token_int)
-                prefix_len = longest_common_suffix_prefix_with_tolerance(prev_token_int, token_int, 6)
-                common_prefix = rich_transcription_postprocess(self.tokenizer.tokens2text(token_int[:prefix_len]))
-
-                asr_res[-1] = asr_res[-1][:-len(common_prefix)]
-            prev_token_int = np.copy(token_int)
-
-            asr_res.append(self.tokenizer.tokens2text(token_int))
+            if self.tokenizer is not None:
+                asr_res.append(self.tokenizer.tokens2text(token_int))
+            else:
+                asr_res.append(token_int)
 
         return asr_res
     
-    def infer(self, filepath_or_data: Union[np.ndarray, str], print_rtf=True):
+    def infer(self, filepath_or_data: Union[np.ndarray, str], language="auto", print_rtf=True):
         if isinstance(filepath_or_data, str):
             waveform = self.load_data(filepath_or_data)
         else:
@@ -227,7 +224,7 @@ class SenseVoiceAx:
         total_time = waveform.shape[-1] / self.sample_rate
 
         start = time.time()
-        asr_res = self.infer_waveform(waveform)
+        asr_res = self.infer_waveform(waveform, language)
         latency = time.time() - start
 
         if print_rtf:

embeddings/position_encoding.npy

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:406a92d1305e9ddd5e7538e0a5849ca3128a1922970acdf75ee9d953e6983850
-size 152448
+oid sha256:0f1c9c550bd62fa164a959517f52d46a28591812fafdf002df0df2bd998f44b5
+size 573568

gradio_demo.py

@@ -0,0 +1,78 @@
+import gradio as gr
+import os
+from SenseVoiceAx import SenseVoiceAx
+from tokenizer import SentencepiecesTokenizer
+from print_utils import rich_transcription_postprocess
+from download_utils import download_model
+
+use_itn = True # 标点符号预测
+max_len = 68
+
+model_path_root = download_model("SenseVoice")
+model_path = os.path.join(model_path_root, "sensevoice_ax650", "sensevoice.axmodel")
+bpemodel = os.path.join(model_path_root, "chn_jpn_yue_eng_ko_spectok.bpe.model")
+
+assert os.path.exists(model_path), f"model {model_path} not exist"
+
+tokenizer = SentencepiecesTokenizer(bpemodel=bpemodel)
+pipeline = SenseVoiceAx(model_path, 
+                        max_len=max_len,
+                        language="auto", 
+                        use_itn=use_itn, 
+                        tokenizer=tokenizer)
+# 你实现的语言转文本函数
+def speech_to_text(audio_path, lang):
+    """
+    audio_path: 音频文件路径
+    lang: 语言类型 "auto", "zh", "en", "yue", "ja", "ko"
+    """
+    if not audio_path:
+        return "无音频"
+    
+    pipeline.choose_language(language=lang)
+    asr_res = pipeline.infer(audio_path, print_rtf=True)
+    res = " ".join([rich_transcription_postprocess(i) for i in asr_res])
+    # TODO: 这里写你的语音识别逻辑
+    # 返回一个示例文本
+    return res
+
+
+def main():
+    with gr.Blocks() as demo:
+        with gr.Row():
+            output_text = gr.Textbox(
+                label="识别结果",
+                lines=5
+            )
+            
+
+        with gr.Row():
+            audio_input = gr.Audio(
+                sources=["microphone"],
+                type="filepath",
+                label="录制或上传音频",
+                format="mp3"
+            )
+            lang_dropdown = gr.Dropdown(
+                choices=["auto", "zh", "en", "yue", "ja", "ko"],
+                value="auto",
+                label="选择音频语言"
+            )
+
+        
+
+
+        audio_input.change(
+            fn=speech_to_text,
+            inputs=[audio_input, lang_dropdown],
+            outputs=output_text
+        )
+
+    demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            ssl_certfile="./cert.pem", ssl_keyfile="./key.pem", ssl_verify=False
+        )
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -2,4 +2,7 @@ huggingface_hub
 numpy<2
 kaldi-native-fbank
 librosa==0.9.1
-sentencepiece
+sentencepiece
+fastapi
+gradio
+emoji

sensevoice_ax650/sensevoice.axmodel

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bd4f1df559d3788c2873eccad31a4e58260a1342a0cdacdad959b324fb155974
-size 261965288
+oid sha256:fad2f710930c23c91ea62d6951c0c6161194e3cf356fc31611798419c6638dd9
+size 262381979

server.py

@@ -0,0 +1,134 @@
+import numpy as np
+from fastapi import FastAPI, HTTPException, Body
+from fastapi.responses import JSONResponse
+from typing import List, Optional
+import logging
+import json
+from SenseVoiceAx import SenseVoiceAx
+from tokenizer import SentencepiecesTokenizer
+from print_utils import rich_transcription_postprocess, rich_print_asr_res
+from download_utils import download_model
+import os
+import librosa
+
+# 初始化日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="ASR Server", description="Automatic Speech Recognition API")
+
+# 全局变量存储模型
+asr_model = None
+
+@app.on_event("startup")
+async def load_model():
+    """
+    服务启动时加载ASR模型
+    """
+    global asr_model
+    logger.info("Loading ASR model...")
+    
+    try:
+        # 模型加载
+        language = "auto"
+        use_itn = True # 标点符号预测
+        max_len = 68
+
+        model_path_root = download_model("SenseVoice")
+        model_path = os.path.join(model_path_root, "sensevoice_ax650", "sensevoice.axmodel")
+        bpemodel = os.path.join(model_path_root, "chn_jpn_yue_eng_ko_spectok.bpe.model")
+
+        assert os.path.exists(model_path), f"model {model_path} not exist"
+
+        print(f"language: {language}")
+        print(f"use_itn: {use_itn}")
+        print(f"model_path: {model_path}")
+
+        tokenizer = SentencepiecesTokenizer(bpemodel=bpemodel)
+        asr_model = SenseVoiceAx(model_path, 
+                                max_len=max_len,
+                                language=language, 
+                                use_itn=use_itn, 
+                                tokenizer=tokenizer)
+        
+        logger.info("ASR model loaded successfully")
+    except Exception as e:
+        logger.error(f"Failed to load ASR model: {str(e)}")
+        raise
+
+def validate_audio_data(audio_data: List[float]) -> np.ndarray:
+    """
+    验证并转换音频数据为numpy数组
+    
+    参数:
+    - audio_data: 浮点数列表表示的音频数据
+    
+    返回:
+    - 验证后的numpy数组
+    """
+    try:
+        # 转换为numpy数组
+        np_array = np.array(audio_data, dtype=np.float32)
+        
+        # 验证数据有效性
+        if np_array.ndim != 1:
+            raise ValueError("Audio data must be 1-dimensional")
+            
+        if len(np_array) == 0:
+            raise ValueError("Audio data cannot be empty")
+            
+        return np_array
+    except Exception as e:
+        raise ValueError(f"Invalid audio data: {str(e)}")
+    
+@app.get("/get_language", summary="Get current language")
+async def get_language():
+    return JSONResponse(content={"language": asr_model.language})
+
+@app.get("/get_language_options", summary="Get possible language options, possible options include [auto, zh, en, yue, ja, ko]")
+async def get_language_options():
+    return JSONResponse(content={"language_options": asr_model.language_options})
+
+@app.post("/asr", summary="Recognize speech from numpy audio data")
+async def recognize_speech(
+    audio_data: List[float] = Body(..., embed=True, description="Audio data as list of floats"),
+    sample_rate: Optional[int] = Body(16000, description="Audio sample rate in Hz"),
+    language: Optional[str] = Body("auto", description="Language")
+):
+    """
+    接收numpy数组格式的音频数据并返回识别结果
+    
+    参数:
+    - audio_data: 浮点数列表表示的音频数据
+    - sample_rate: 音频采样率(默认16000Hz)
+    
+    返回:
+    - JSON包含识别文本
+    """
+    try:
+        # 检查模型是否已加载
+        if asr_model is None:
+            raise HTTPException(status_code=503, detail="ASR model not loaded")
+        
+        logger.info(f"Received audio data with length: {len(audio_data)}")
+        
+        # 验证并转换数据
+        np_audio = validate_audio_data(audio_data)
+        if sample_rate != asr_model.sample_rate:
+            np_audio = librosa.resample(np_audio, sample_rate, asr_model.sample_rate)
+        
+        # 调用模型进行识别
+        result = asr_model.infer_waveform(np_audio, language)
+        
+        return JSONResponse(content={"text": result})
+    
+    except ValueError as e:
+        logger.error(f"Validation error: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Recognition error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

test_wer.py

@@ -4,73 +4,267 @@ from SenseVoiceAx import SenseVoiceAx
 from tokenizer import SentencepiecesTokenizer
 from print_utils import rich_transcription_postprocess, rich_print_asr_res
 from download_utils import download_model
-import jiwer
+import logging
+import re
+import emoji
 
 
+def setup_logging():
+    """配置日志系统，同时输出到控制台和文件"""
+    # 获取脚本所在目录
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    log_file = os.path.join(script_dir, "test_wer.log")
+    
+    # 配置日志格式
+    log_format = '%(asctime)s - %(levelname)s - %(message)s'
+    date_format = '%Y-%m-%d %H:%M:%S'
+    
+    # 创建logger
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+    
+    # 清除现有的handler
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
+    
+    # 创建文件handler
+    file_handler = logging.FileHandler(log_file, mode='w', encoding='utf-8')
+    file_handler.setLevel(logging.INFO)
+    file_formatter = logging.Formatter(log_format, date_format)
+    file_handler.setFormatter(file_formatter)
+    
+    # 创建控制台handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    console_formatter = logging.Formatter(log_format, date_format)
+    console_handler.setFormatter(console_formatter)
+    
+    # 添加handler到logger
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+    
+    return logger
+
+
+class AIShellDataset:
+    def __init__(self, gt_path: str):
+        """
+        初始化数据集
+        
+        Args:
+            json_path: voice.json文件的路径
+        """
+        self.gt_path = gt_path
+        self.dataset_dir = os.path.dirname(gt_path)
+        self.voice_dir = os.path.join(self.dataset_dir, "aishell_S0764")
+        
+        # 检查必要文件和文件夹是否存在
+        assert os.path.exists(gt_path), f"gt文件不存在: {gt_path}"
+        assert os.path.exists(self.voice_dir), f"aishell_S0764文件夹不存在: {self.voice_dir}"
+        
+        # 加载数据
+        self.data = []
+        with open(gt_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                audio_path, gt = line.split(" ")
+                audio_path = os.path.join(self.voice_dir, audio_path + ".wav")
+                self.data.append({"audio_path": audio_path, "gt": gt})
+
+        # 使用logging而不是print
+        logger = logging.getLogger()
+        logger.info(f"加载了 {len(self.data)} 条数据")
+    
+    def __iter__(self):
+        """返回迭代器"""
+        self.index = 0
+        return self
+    
+    def __next__(self):
+        """返回下一个数据项"""
+        if self.index >= len(self.data):
+            raise StopIteration
+        
+        item = self.data[self.index]
+        audio_path = item["audio_path"]
+        ground_truth = item["gt"]
+        
+        self.index += 1
+        return audio_path, ground_truth
+    
+    def __len__(self):
+        """返回数据集大小"""
+        return len(self.data)
+    
+
+class CommonVoiceDataset:
+    """Common Voice数据集解析器"""
+    
+    def __init__(self, tsv_path: str):
+        """
+        初始化数据集
+        
+        Args:
+            json_path: voice.json文件的路径
+        """
+        self.tsv_path = tsv_path
+        self.dataset_dir = os.path.dirname(tsv_path)
+        self.voice_dir = os.path.join(self.dataset_dir, "clips")
+        
+        # 检查必要文件和文件夹是否存在
+        assert os.path.exists(tsv_path), f"{tsv_path}文件不存在: {tsv_path}"
+        assert os.path.exists(self.voice_dir), f"voice文件夹不存在: {self.voice_dir}"
+        
+        # 加载JSON数据
+        self.data = []
+        with open(tsv_path, 'r', encoding='utf-8') as f:
+            f.readline()
+            for line in f:
+                line = line.strip()
+                splits = line.split("\t")
+                audio_path = splits[1]
+                gt = splits[3]
+                audio_path = os.path.join(self.voice_dir, audio_path)
+                self.data.append({"audio_path": audio_path, "gt": gt})
+        
+        # 使用logging而不是print
+        logger = logging.getLogger()
+        logger.info(f"加载了 {len(self.data)} 条数据")
+    
+    def __iter__(self):
+        """返回迭代器"""
+        self.index = 0
+        return self
+    
+    def __next__(self):
+        """返回下一个数据项"""
+        if self.index >= len(self.data):
+            raise StopIteration
+        
+        item = self.data[self.index]
+        audio_path = item["audio_path"]
+        ground_truth = item["gt"]
+        
+        self.index += 1
+        return audio_path, ground_truth
+    
+    def __len__(self):
+        """返回数据集大小"""
+        return len(self.data)
+    
+
 def get_args():
     parser = argparse.ArgumentParser()
-    parser.add_argument("--dataset", "-d", required=True, type=str, help="Input dataset")
+    parser.add_argument("--dataset", "-d", type=str, required=True, choices=["aishell", "common_voice"], help="Test dataset")
+    parser.add_argument("--gt_path", "-g", type=str, required=True, help="Test dataset ground truth file")
     parser.add_argument("--language", "-l", required=False, type=str, default="auto", choices=["auto", "zh", "en", "yue", "ja", "ko"])
+    parser.add_argument("--max_num", type=int, default=-1, required=False, help="Maximum test data num")
     return parser.parse_args()
 
 
+def min_distance(word1: str, word2: str) -> int:
+ 
+    row = len(word1) + 1
+    column = len(word2) + 1
+ 
+    cache = [ [0]*column for i in range(row) ]
+ 
+    for i in range(row):
+        for j in range(column):
+ 
+            if i ==0 and j ==0:
+                cache[i][j] = 0
+            elif i == 0 and j!=0:
+                cache[i][j] = j
+            elif j == 0 and i!=0:
+                cache[i][j] = i
+            else:
+                if word1[i-1] == word2[j-1]:
+                    cache[i][j] = cache[i-1][j-1]
+                else:
+                    replace = cache[i-1][j-1] + 1
+                    insert = cache[i][j-1] + 1
+                    remove = cache[i-1][j] + 1
+ 
+                    cache[i][j] = min(replace, insert, remove)
+ 
+    return cache[row-1][column-1]
+
+
+def remove_punctuation(text):
+    # 定义正则表达式模式，匹配所有标点符号
+    # 这个模式包括常见的标点符号和中文标点
+    pattern = r'[^\w\s]|_'
+    
+    # 使用sub方法将所有匹配的标点符号替换为空字符串
+    cleaned_text = re.sub(pattern, '', text)
+    
+    return cleaned_text
+
+
 def main():
+    logger = setup_logging()
     args = get_args()
 
-    dataset = args.dataset
     language = args.language
     use_itn = False # 标点符号预测
+    max_num = args.max_num
+
+    dataset_type = args.dataset.lower()
+    if dataset_type == "aishell":
+        dataset = AIShellDataset(args.gt_path)
+    elif dataset_type == "common_voice":
+        dataset = CommonVoiceDataset(args.gt_path)
+    else:
+        raise ValueError(f"Unknown dataset type {dataset_type}")
 
     model_path_root = download_model("SenseVoice")
-    model_path = os.path.join(model_path_root, "sensevoice_ax650", "sensevoice.axmodel")
+    # model_path = os.path.join(model_path_root, "sensevoice_ax650", "sensevoice.axmodel")
+    model_path = "./model_convert/output_dir/model.onnx"
     bpemodel = os.path.join(model_path_root, "chn_jpn_yue_eng_ko_spectok.bpe.model")
 
     assert os.path.exists(model_path), f"model {model_path} not exist"
 
-    print(f"dataset: {dataset}")
-    print(f"language: {language}")
-    print(f"use_itn: {use_itn}")
-    print(f"model_path: {model_path}")
+    logger.info(f"dataset: {args.dataset}")
+    logger.info(f"language: {language}")
+    logger.info(f"use_itn: {use_itn}")
+    logger.info(f"model_path: {model_path}")
 
     tokenizer = SentencepiecesTokenizer(bpemodel=bpemodel)
-    pipeline = SenseVoiceAx(model_path, language, use_itn, tokenizer=tokenizer)
-
-    # Load dataset
-    wav_names = []
-    references = []
-    with open(os.path.join(dataset, "ground_truth.txt"), "r") as f:
-        for line in f:
-            line = line.strip()
-            w, r = line.split(" ")
-            wav_names.append(w)
-            references.append(r)
+    pipeline = SenseVoiceAx(model_path, language=language, use_itn=use_itn, tokenizer=tokenizer, max_len=256)
 
     # Iterate over dataset
     hyp = []
-    wer_file = open("wer.txt", "w")
-    for wav_name, reference in zip(wav_names, references):
-        wav_path = os.path.join(dataset, "aishell_S0764", wav_name + ".wav")
+    references = []
+    all_character_error_num = 0
+    all_character_num = 0
+    max_data_num = max_num if max_num > 0 else len(dataset)
+    for n, (audio_path, reference) in enumerate(dataset):
+        reference = remove_punctuation(reference).lower()
 
-        asr_res = pipeline.infer(wav_path, print_rtf=False)
-        hypothesis = rich_print_asr_res(asr_res, will_print=False, remove_punc=True)
-        hyp.append(hypothesis)
+        asr_res = pipeline.infer(audio_path, print_rtf=False)
+        hypothesis = rich_print_asr_res(asr_res, will_print=False, remove_punc=True).lower()
+        hypothesis = emoji.replace_emoji(hypothesis, replace='')
+
+        character_error_num = min_distance(reference, hypothesis)
+        character_num = len(reference)
+        character_error_rate = character_error_num / character_num * 100
 
-        wer = jiwer.cer(
-                    reference,
-                    hypothesis
-                )
+        all_character_error_num += character_error_num
+        all_character_num += character_num
+
+        hyp.append(hypothesis)
+        references.append(reference)
         
-        line_content = f"{wav_name}  reference: {reference}  hypothesis: {hypothesis}  WER: {wer}"
-        wer_file.write(line_content + "\n")
-        print(line_content)
-
-    total_wer = jiwer.cer(
-                    references,
-                    hyp
-                )
-    print(f"Total WER: {total_wer}")
-    wer_file.write(f"Total WER: {total_wer}")
-    wer_file.close()
+        line_content = f"({n+1}/{max_data_num}) {os.path.basename(audio_path)}  gt: {reference}  predict: {hypothesis}  WER: {character_error_rate}%"
+        logger.info(line_content)
+
+        if n + 1 >= max_data_num:
+            break
+
+    total_character_error_rate = all_character_error_num / all_character_num * 100
+
+    logger.info(f"Total WER: {total_character_error_rate}%")
 
 if __name__ == "__main__":
     main()