# 前言

在語音識別中，模型輸出的結果只是單純的文本結果，並沒有根據語法添加標點符號，本教程就是針對這種情況，在語音識別文本中根據語法情況加入標點符號，使得語音識別系統能夠輸出在標點符號的最終結果。
注意，本教程只介紹使用，如果要訓練自己的模型，需要看《基於PaddlePaddle訓練中文標點符號模型》文章。

使用¶

使用主要分爲三4步：

首先是下載模型，並解壓到models/目錄下，下載地址如下：

https://download.csdn.net/download/qq_33200967/75664996

需要使用PaddleNLP工具，所以需要提前安裝PaddleNLP，安裝命令如下：

python -m pip install paddlenlp -i https://mirrors.aliyun.com/pypi/simple/

PPASR在0.1.3版本之後開始提供，提供了自動添加標點符號的工具，我們可以通過安裝ppasr，來使用這個工具。

python -m pip install ppasr==2.4.8 -i https://mirrors.aliyun.com/pypi/simple/

對文本自動加上了標點符號，使用非常簡單，如下。注意在V2版本之後導入庫的路徑變了，然後名稱也變了。

from ppasr.infer_utils.pun_predictor import PunctuationPredictor

pun_predictor = PunctuationPredictor(model_dir='models/pun_models')
result = pun_predictor('近幾年不但我用書給女兒兒壓歲也勸說親朋不要給女兒壓歲錢而改送壓歲書')
print(result)

輸出結果：

[2022-01-13 15:27:11,194] [    INFO] - Found C:\Users\test\.paddlenlp\models\ernie-1.0\vocab.txt
近幾年，不但我用書給女兒兒壓歲，也勸說親朋，不要給女兒壓歲錢，而改送壓歲書。

源碼地址，這個工具的全部源碼如下：

import json
import os
import re

import numpy as np
import paddle.inference as paddle_infer
from paddlenlp.transformers import ErnieTokenizer
from ppasr.utils.logger import setup_logger

logger = setup_logger(__name__)

__all__ = ['PunctuationPredictor']


class PunctuationPredictor:
    def __init__(self, model_dir, use_gpu=True, gpu_mem=500, num_threads=4):
        # 創建 config
        model_path = os.path.join(model_dir, 'model.pdmodel')
        params_path = os.path.join(model_dir, 'model.pdiparams')
        if not os.path.exists(model_path) or not os.path.exists(params_path):
            raise Exception("標點符號模型文件不存在，請檢查{}和{}是否存在！".format(model_path, params_path))
        self.config = paddle_infer.Config(model_path, params_path)
        # 獲取預訓練模型類型
        pretrained_token = 'ernie-1.0'
        if os.path.exists(os.path.join(model_dir, 'info.json')):
            with open(os.path.join(model_dir, 'info.json'), 'r', encoding='utf-8') as f:
                data = json.load(f)
                pretrained_token = data['pretrained_token']

        if use_gpu:
            self.config.enable_use_gpu(gpu_mem, 0)
        else:
            self.config.disable_gpu()
            self.config.set_cpu_math_library_num_threads(num_threads)
        # enable memory optim
        self.config.enable_memory_optim()
        self.config.disable_glog_info()

        # 根據 config 創建 predictor
        self.predictor = paddle_infer.create_predictor(self.config)

        # 獲取輸入層
        self.input_ids_handle = self.predictor.get_input_handle('input_ids')
        self.token_type_ids_handle = self.predictor.get_input_handle('token_type_ids')

        # 獲取輸出的名稱
        self.output_names = self.predictor.get_output_names()

        self._punc_list = []
        if not os.path.join(model_dir, 'vocab.txt'):
            raise Exception("字典文件不存在，請檢查{}是否存在！".format(os.path.join(model_dir, 'vocab.txt')))
        with open(os.path.join(model_dir, 'vocab.txt'), 'r', encoding='utf-8') as f:
            for line in f:
                self._punc_list.append(line.strip())

        self.tokenizer = ErnieTokenizer.from_pretrained(pretrained_token)

        # 預熱
        self('近幾年不但我用書給女兒兒壓歲也勸說親朋不要給女兒壓歲錢而改送壓歲書')
        logger.info('標點符號模型加載成功。')

    def _clean_text(self, text):
        text = text.lower()
        text = re.sub('[^A-Za-z0-9\u4e00-\u9fa5]', '', text)
        text = re.sub(f'[{"".join([p for p in self._punc_list][1:])}]', '', text)
        return text

    # 預處理文本
    def preprocess(self, text: str):
        clean_text = self._clean_text(text)
        if len(clean_text) == 0: return None
        tokenized_input = self.tokenizer(list(clean_text), return_length=True, is_split_into_words=True)
        input_ids = tokenized_input['input_ids']
        seg_ids = tokenized_input['token_type_ids']
        seq_len = tokenized_input['seq_len']
        return input_ids, seg_ids, seq_len

    def infer(self, input_ids: list, seg_ids: list):
        # 設置輸入
        self.input_ids_handle.reshape([1, len(input_ids)])
        self.token_type_ids_handle.reshape([1, len(seg_ids)])
        self.input_ids_handle.copy_from_cpu(np.array([input_ids]).astype('int64'))
        self.token_type_ids_handle.copy_from_cpu(np.array([seg_ids]).astype('int64'))

        # 運行predictor
        self.predictor.run()

        # 獲取輸出
        output_handle = self.predictor.get_output_handle(self.output_names[0])
        output_data = output_handle.copy_to_cpu()
        return output_data

    # 後處理識別結果
    def postprocess(self, input_ids, seq_len, preds):
        tokens = self.tokenizer.convert_ids_to_tokens(input_ids[1:seq_len - 1])
        labels = preds[1:seq_len - 1].tolist()
        assert len(tokens) == len(labels)

        text = ''
        for t, l in zip(tokens, labels):
            text += t
            if l != 0:
                text += self._punc_list[l]
        return text

    def __call__(self, text: str) -> str:
        # 數據batch處理
        try:
            input_ids, seg_ids, seq_len = self.preprocess(text)
            preds = self.infer(input_ids=input_ids, seg_ids=seg_ids)
            if len(preds.shape) == 2:
                preds = preds[0]
            text = self.postprocess(input_ids, seq_len, preds)
        except Exception as e:
            logger.error(e)
        return text

使用¶

參考資料¶

相關文章