update

data/call_monitor_examples_wav.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1fb1f13a364c82a49824d0943cc75a471bdd054fc561c661e57f3e69092fc048
-size 307796
+oid sha256:ac3448d2c7a017270dc9e9dc304d66e8bff6caccc7f011bdcbe5febeddbf316c
+size 2129737

examples/channel_dual_to_single.py

@@ -0,0 +1,56 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import os
+from pathlib import Path
+
+from scipy.io import wavfile
+from tqdm import tqdm
+
+from project_settings import project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--wav_dir",
+        default=(project_path / "data/early_media/60/wav").as_posix(),
+        type=str
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    wav_dir = Path(args.wav_dir)
+    for filename in tqdm(wav_dir.glob("*.wav")):
+        print(filename)
+
+        try:
+            sample_rate, signal = wavfile.read(filename)
+        except UnboundLocalError:
+            os.remove(filename)
+            continue
+        if sample_rate != 8000:
+            raise AssertionError
+
+        if len(signal) < 1.0 * sample_rate:
+            os.remove(filename.as_posix())
+            continue
+
+        # print(signal.shape)
+        signal = signal[:, 0]
+        # print(signal.shape)
+
+        wavfile.write(filename.as_posix(), rate=8000, data=signal)
+        # wavfile.write("temp2.wav", rate=8000, data=signal)
+        # exit(0)
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/make_early_media_speech_wav/step_1_make_media_speech.py

@@ -0,0 +1,220 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+from scipy.io import wavfile
+import torch
+from tqdm import tqdm
+from typing import List
+
+from project_settings import project_path
+from toolbox.cv2.misc import show_image, erode, dilate
+from toolbox.python_speech_features.misc import wave2spectrum_image
+
+
+area_code = 60
+
+
+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
+    )
+    parser.add_argument(
+        "--media_speech_dir",
+        default=(project_path / "data/early_media/{area_code}/media_speech".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    parser.add_argument("--win_size", default=2, type=int)
+    parser.add_argument("--win_step", default=1, type=int)
+    args = parser.parse_args()
+    return args
+
+
+class PyTorchSpectrumTagger(object):
+    def __init__(self,
+                 seq2seq_encoder_pth: str,
+                 seq2vec_encoder_pth: str,
+                 classification_layer_pth: str,
+                 index2token_json: str,
+                 win_size: int = 50,
+                 win_step: int = 25,
+                 ):
+        self.seq2seq_encoder_pth = seq2seq_encoder_pth
+        self.seq2vec_encoder_pth = seq2vec_encoder_pth
+        self.classification_layer_pth = classification_layer_pth
+        self.index2token_json = index2token_json
+        self.win_size = win_size
+        self.win_step = win_step
+
+        self.seq2seq_encoder = torch.jit.load(self.seq2seq_encoder_pth)
+        self.seq2vec_encoder = torch.jit.load(self.seq2vec_encoder_pth)
+        self.classification_layer = torch.jit.load(self.classification_layer_pth)
+        with open(self.index2token_json, "r", encoding="utf-8") as f:
+            index2token = json.load(f)
+        self.index2token = index2token
+
+    def tag(self, spectrum: np.ndarray):
+        array = np.expand_dims(spectrum, axis=0)
+        array = torch.tensor(array, dtype=torch.float32)
+        mask: torch.IntTensor = torch.ones(size=array.shape[:-1], device=array.device, dtype=torch.int32)
+
+        array = self.seq2seq_encoder.forward(array, mask=mask)
+
+        length = array.shape[-2]
+
+        result = list()
+        idx = 0
+        while True:
+            begin = idx * self.win_step
+            end = begin + self.win_size
+            if end > length:
+                break
+            window = array[:, begin:end, :]
+            window = self.seq2vec_encoder.forward(window)
+            logits = self.classification_layer(window)
+            probs = torch.nn.functional.softmax(logits, dim=-1)
+            label_idx = probs.argmax(dim=-1).item()
+            label_str = self.index2token[str(label_idx)]
+            result.append(label_str)
+            idx += 1
+
+        return result
+
+
+def correct_labels(labels: List[str]):
+        """
+        (1)
+        先消极零散的 music 标签.
+
+        (2)
+        1. 扩张. 将零散的 voice 标签连接起来.
+        2. 侵蚀. 返回原长度. 并消除零散 voice 标签
+        3. 扩张. 扩张 voice 标签, 以保障模板匹配的充分.
+        :param labels:
+        :return:
+        """
+        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)
+
+        return labels
+
+
+def split_signal_by_labels(signal: np.ndarray, labels: List[str]):
+    l = len(labels)
+
+    voice = list()
+    begin = None
+    for idx, label in enumerate(labels):
+        if label == "voice":
+            if begin is None:
+                begin = idx
+        elif label != "voice":
+            if begin is not None:
+                voice.append((begin, idx))
+                begin = None
+        else:
+            pass
+    else:
+        if begin is not None:
+            voice.append((begin, l))
+
+    result = list()
+
+    win_size = signal.shape[0] / l
+    for begin, end in voice:
+        begin = int(begin * win_size)
+        end = int(end * win_size)
+
+        sub_signal = signal[begin: end + 1]
+        result.append({
+            "begin": begin,
+            "sub_signal": sub_signal,
+        })
+
+    return result
+
+
+def main():
+    args = get_args()
+
+    max_wave_value = 32768.0
+
+    model_dir = Path(args.model_dir)
+    wav_dir = Path(args.wav_dir)
+    media_speech_dir = Path(args.media_speech_dir)
+
+    spectrum_tagger = PyTorchSpectrumTagger(
+        seq2seq_encoder_pth=model_dir / "seq2seq_encoder.pth",
+        seq2vec_encoder_pth=model_dir / "seq2vec_encoder.pth",
+        classification_layer_pth=model_dir / "classification_layer.pth",
+        index2token_json=model_dir / "index2token.json",
+    )
+
+    for filename in tqdm(wav_dir.glob("*/*.wav")):
+        if filename.parts[-2] in ("bell", "music"):
+            continue
+        sample_rate, signal = wavfile.read(filename)
+
+        if len(signal) < 1.0 * sample_rate:
+            continue
+
+        signal_ = signal / max_wave_value
+
+        spectrum = wave2spectrum_image(
+            signal_,
+            sample_rate=8000,
+            xmax=10,
+            xmin=-50,
+            winlen=0.025,
+            winstep=0.01,
+            nfft=512,
+            n_low_freq=100,
+        )
+        # show_image(array.T)
+
+        labels = spectrum_tagger.tag(spectrum)
+        labels = correct_labels(labels)
+
+        if "voice" not in labels:
+            continue
+
+        sub_signal_list = split_signal_by_labels(signal, labels)
+
+        for i, sub_signal_group in enumerate(sub_signal_list):
+            to_dir = media_speech_dir / filename.parts[-2]
+            to_dir.mkdir(exist_ok=True)
+            to_filename = to_dir / "{}_{}.wav".format(filename.stem, i)
+
+            sub_signal = sub_signal_group["sub_signal"]
+
+            sub_signal = np.array(sub_signal, dtype=np.int16)
+            if len(sub_signal) < sample_rate * 4:
+                continue
+
+            wavfile.write(
+                filename=to_filename,
+                rate=sample_rate,
+                data=sub_signal
+            )
+
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/make_early_media_speech_wav/step_2_make_annotations.py

@@ -0,0 +1,79 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.io import wavfile
+import torch
+from tqdm import tqdm
+from typing import List
+
+from project_settings import project_path
+from toolbox.cv2.misc import show_image, erode, dilate
+from toolbox.python_speech_features.misc import wave2spectrum_image
+
+
+area_code = 60
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--media_speech_dir",
+        default=(project_path / "data/early_media/{area_code}/media_speech".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--annotations_file",
+        default=(project_path / "data/early_media/{area_code}/media_speech/annotations.xlsx".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    media_speech_dir = Path(args.media_speech_dir)
+    annotations_file = Path(args.annotations_file)
+
+    name_to_row = dict()
+    if annotations_file.exists():
+        df = pd.read_excel(annotations_file.as_posix())
+        for i, row in df.iterrows():
+            row = dict(row)
+            name = row["filename"]
+            name_to_row[name] = row
+
+    result = list()
+    for filename in tqdm(media_speech_dir.glob("*/*.wav")):
+        filename = Path(filename)
+        relative_name = filename.relative_to(media_speech_dir)
+
+        name = relative_name.as_posix()
+        row = name_to_row.get(name)
+        if row is None:
+            text = ""
+        else:
+            text = row["text"]
+
+        result.append({
+            "filename": name,
+            "text": text
+        })
+
+    result = pd.DataFrame(result)
+    result.to_excel(
+        annotations_file.as_posix(),
+        index=False,
+        encoding="utf_8_sig"
+    )
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/make_full_user_wav/step_1_make_full_uer_wav.py

@@ -0,0 +1,92 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import os
+from pathlib import Path
+
+import numpy as np
+from scipy.io import wavfile
+from tqdm import tqdm
+
+from project_settings import project_path
+
+
+area_code = 60
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--calling_wav_dir",
+        default=(project_path / "data/calling/{area_code}/wav".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--early_media_wav_dir",
+        default=(project_path / "data/early_media/{area_code}/wav".format(area_code=area_code)).as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--output_dir",
+        default=(project_path / "data/call_monitor_examples_wav/ms-MY").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--query",
+        default="2b626374-8f27-4b50-90b7-47cbfa10accc",
+        type=str
+    )
+    parser.add_argument(
+        "--expected_sample_rate",
+        default=8000,
+        type=int
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    calling_wav_dir = Path(args.calling_wav_dir)
+    early_media_wav_dir = Path(args.early_media_wav_dir)
+    output_dir = Path(args.output_dir)
+
+    # calling
+    calling_signal = np.zeros(shape=(0,), dtype=np.int16)
+    for filename in tqdm(calling_wav_dir.glob("**/*.wav")):
+        basename = filename.stem
+        # print(basename)
+        if str(basename).__contains__(args.query):
+            print(filename)
+
+            sample_rate, signal = wavfile.read(filename)
+            if sample_rate != args.expected_sample_rate:
+                raise AssertionError
+            calling_signal = signal[:, 0]
+
+    # early media
+    early_media_signal = np.zeros(shape=(0,), dtype=np.int16)
+    for filename in tqdm(early_media_wav_dir.glob("**/*.wav")):
+        basename = filename.stem
+        # print(basename)
+        if str(basename).__contains__(args.query):
+            print(filename)
+            sample_rate, signal = wavfile.read(filename)
+            if sample_rate != args.expected_sample_rate:
+                raise AssertionError
+            early_media_signal = signal
+
+    on_answer_ts = int(len(early_media_signal) / args.expected_sample_rate * 1000)
+    print("on_answer_ts: {}".format(on_answer_ts))
+
+    signal = np.concatenate([early_media_signal, calling_signal], axis=0)
+
+    to_filename = output_dir / "{}.wav".format(args.query)
+    wavfile.write(to_filename.as_posix(), rate=8000, data=signal)
+
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/make_templates/step_1_wav_classification.py

@@ -24,7 +24,7 @@ from toolbox.cv2.misc import show_image
 from toolbox.python_speech_features.misc import wave2spectrum_image
 
 
-area_code = 55
+area_code = 60
 
 
 def get_args():

examples/make_templates/step_2_wav_split.py

@@ -18,19 +18,19 @@ from tqdm import tqdm
 from project_settings import project_path
 
 
-area_code = 91
+area_code = 60
 
 
 def get_args():
     parser = argparse.ArgumentParser()
     parser.add_argument(
         "--filename",
-        default=(project_path / "data/wav/91/91_wav/voice/91_1699977085057.wav").as_posix(),
+        default=(project_path / "data/early_media/60/wav/voice/early_vm_e4543473-eab8-4240-8e9c-d5249a1137b5.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(),
+        default=(project_path / "data/early_media/{area_code}/temp".format(area_code=area_code)).as_posix(),
         type=str
     )
     parser.add_argument("--win_size", default=2.0, type=float)

examples/make_templates/step_3_move_by_template.py

@@ -18,7 +18,7 @@ from project_settings import project_path
 from toolbox.python_speech_features.misc import wave2spectrum_image
 
 
-area_code = 55
+area_code = 60
 
 
 def get_args():
@@ -203,8 +203,8 @@ def main():
         if len(set(labels_)) > 1:
             print("超过两个模板类别被匹配，请检测是否匹配正确。")
             print(filename)
-            for match in matches:
-                print(match)
+            # for match in matches:
+            #     print(match)
             continue
 
         if len(labels_) == 0:

examples/seach_early_media_wav.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import os
+from pathlib import Path
+
+from scipy.io import wavfile
+from tqdm import tqdm
+
+from project_settings import project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--wav_dir",
+        default=(project_path / "data/early_media/60/wav").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--query",
+        default="e9b985ea-aca6-4e04-87ab-e51271503f4c",
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    wav_dir = Path(args.wav_dir)
+    for filename in tqdm(wav_dir.glob("*/*.wav")):
+        basename = filename.stem
+        # print(basename)
+        if str(basename).__contains__(args.query):
+            print(filename)
+    return
+
+
+if __name__ == '__main__':
+    main()

toolbox/torch/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/torch/utils/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/torch/utils/data/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/torch/utils/data/vocabulary.py

@@ -0,0 +1,211 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from collections import defaultdict, OrderedDict
+import os
+from typing import Any, Callable, Dict, Iterable, List, Set
+
+
+def namespace_match(pattern: str, namespace: str):
+    """
+    Matches a namespace pattern against a namespace string.  For example, ``*tags`` matches
+    ``passage_tags`` and ``question_tags`` and ``tokens`` matches ``tokens`` but not
+    ``stemmed_tokens``.
+    """
+    if pattern[0] == '*' and namespace.endswith(pattern[1:]):
+        return True
+    elif pattern == namespace:
+        return True
+    return False
+
+
+class _NamespaceDependentDefaultDict(defaultdict):
+    def __init__(self,
+                 non_padded_namespaces: Set[str],
+                 padded_function: Callable[[], Any],
+                 non_padded_function: Callable[[], Any]) -> None:
+        self._non_padded_namespaces = set(non_padded_namespaces)
+        self._padded_function = padded_function
+        self._non_padded_function = non_padded_function
+        super(_NamespaceDependentDefaultDict, self).__init__()
+
+    def __missing__(self, key: str):
+        if any(namespace_match(pattern, key) for pattern in self._non_padded_namespaces):
+            value = self._non_padded_function()
+        else:
+            value = self._padded_function()
+        dict.__setitem__(self, key, value)
+        return value
+
+    def add_non_padded_namespaces(self, non_padded_namespaces: Set[str]):
+        # add non_padded_namespaces which weren't already present
+        self._non_padded_namespaces.update(non_padded_namespaces)
+
+
+class _TokenToIndexDefaultDict(_NamespaceDependentDefaultDict):
+    def __init__(self, non_padded_namespaces: Set[str], padding_token: str, oov_token: str) -> None:
+        super(_TokenToIndexDefaultDict, self).__init__(non_padded_namespaces,
+                                                       lambda: {padding_token: 0, oov_token: 1},
+                                                       lambda: {})
+
+
+class _IndexToTokenDefaultDict(_NamespaceDependentDefaultDict):
+    def __init__(self, non_padded_namespaces: Set[str], padding_token: str, oov_token: str) -> None:
+        super(_IndexToTokenDefaultDict, self).__init__(non_padded_namespaces,
+                                                       lambda: {0: padding_token, 1: oov_token},
+                                                       lambda: {})
+
+
+DEFAULT_NON_PADDED_NAMESPACES = ("*tags", "*labels")
+DEFAULT_PADDING_TOKEN = '[PAD]'
+DEFAULT_OOV_TOKEN = '[UNK]'
+NAMESPACE_PADDING_FILE = 'non_padded_namespaces.txt'
+
+
+class Vocabulary(object):
+    def __init__(self, non_padded_namespaces: Iterable[str] = DEFAULT_NON_PADDED_NAMESPACES):
+        self._non_padded_namespaces = set(non_padded_namespaces)
+        self._padding_token = DEFAULT_PADDING_TOKEN
+        self._oov_token = DEFAULT_OOV_TOKEN
+        self._token_to_index = _TokenToIndexDefaultDict(self._non_padded_namespaces,
+                                                        self._padding_token,
+                                                        self._oov_token)
+        self._index_to_token = _IndexToTokenDefaultDict(self._non_padded_namespaces,
+                                                        self._padding_token,
+                                                        self._oov_token)
+
+    def add_token_to_namespace(self, token: str, namespace: str = 'tokens') -> int:
+        if token not in self._token_to_index[namespace]:
+            index = len(self._token_to_index[namespace])
+            self._token_to_index[namespace][token] = index
+            self._index_to_token[namespace][index] = token
+            return index
+        else:
+            return self._token_to_index[namespace][token]
+
+    def get_index_to_token_vocabulary(self, namespace: str = 'tokens') -> Dict[int, str]:
+        return self._index_to_token[namespace]
+
+    def get_token_to_index_vocabulary(self, namespace: str = 'tokens') -> Dict[str, int]:
+        return self._token_to_index[namespace]
+
+    def get_token_index(self, token: str, namespace: str = 'tokens') -> int:
+        if token in self._token_to_index[namespace]:
+            return self._token_to_index[namespace][token]
+        else:
+            return self._token_to_index[namespace][self._oov_token]
+
+    def get_token_from_index(self, index: int, namespace: str = 'tokens'):
+        return self._index_to_token[namespace][index]
+
+    def get_vocab_size(self, namespace: str = 'tokens') -> int:
+        return len(self._token_to_index[namespace])
+
+    def save_to_files(self, directory: str):
+        os.makedirs(directory, exist_ok=True)
+        with open(os.path.join(directory, NAMESPACE_PADDING_FILE), 'w', encoding='utf-8') as f:
+            for namespace_str in self._non_padded_namespaces:
+                f.write('{}\n'.format(namespace_str))
+
+        for namespace, token_to_index in self._token_to_index.items():
+            filename = os.path.join(directory, '{}.txt'.format(namespace))
+            with open(filename, 'w', encoding='utf-8') as f:
+                for token, _ in token_to_index.items():
+                    f.write('{}\n'.format(token))
+
+    @classmethod
+    def from_files(cls, directory: str) -> 'Vocabulary':
+        with open(os.path.join(directory, NAMESPACE_PADDING_FILE), 'r', encoding='utf-8') as f:
+            non_padded_namespaces = [namespace_str.strip() for namespace_str in f]
+
+        vocab = cls(non_padded_namespaces=non_padded_namespaces)
+
+        for namespace_filename in os.listdir(directory):
+            if namespace_filename == NAMESPACE_PADDING_FILE:
+                continue
+            if namespace_filename.startswith("."):
+                continue
+            namespace = namespace_filename.replace('.txt', '')
+            if any(namespace_match(pattern, namespace) for pattern in non_padded_namespaces):
+                is_padded = False
+            else:
+                is_padded = True
+            filename = os.path.join(directory, namespace_filename)
+            vocab.set_from_file(filename, is_padded, namespace=namespace)
+
+        return vocab
+
+    def set_from_file(self,
+                      filename: str,
+                      is_padded: bool = True,
+                      oov_token: str = DEFAULT_OOV_TOKEN,
+                      namespace: str = "tokens"
+                      ):
+        if is_padded:
+            self._token_to_index[namespace] = {self._padding_token: 0}
+            self._index_to_token[namespace] = {0: self._padding_token}
+        else:
+            self._token_to_index[namespace] = {}
+            self._index_to_token[namespace] = {}
+
+        with open(filename, 'r', encoding='utf-8') as f:
+            index = 1 if is_padded else 0
+            for row in f:
+                token = str(row).strip()
+                if token == oov_token:
+                    token = self._oov_token
+                self._token_to_index[namespace][token] = index
+                self._index_to_token[namespace][index] = token
+                index += 1
+
+    def convert_tokens_to_ids(self, tokens: List[str], namespace: str = "tokens"):
+        result = list()
+        for token in tokens:
+            idx = self._token_to_index[namespace].get(token)
+            if idx is None:
+                idx = self._token_to_index[namespace][self._oov_token]
+            result.append(idx)
+        return result
+
+    def convert_ids_to_tokens(self, ids: List[int], namespace: str = "tokens"):
+        result = list()
+        for idx in ids:
+            idx = self._index_to_token[namespace][idx]
+            result.append(idx)
+        return result
+
+    def pad_or_truncate_ids_by_max_length(self, ids: List[int], max_length: int, namespace: str = "tokens"):
+        pad_idx = self._token_to_index[namespace][self._padding_token]
+
+        length = len(ids)
+        if length > max_length:
+            result = ids[:max_length]
+        else:
+            result = ids + [pad_idx] * (max_length - length)
+        return result
+
+
+def demo1():
+    import jieba
+
+    vocabulary = Vocabulary()
+    vocabulary.add_token_to_namespace('白天', 'tokens')
+    vocabulary.add_token_to_namespace('晚上', 'tokens')
+
+    text = '不是在白天, 就是在晚上'
+    tokens = jieba.lcut(text)
+
+    print(tokens)
+
+    ids = vocabulary.convert_tokens_to_ids(tokens)
+    print(ids)
+
+    padded_idx = vocabulary.pad_or_truncate_ids_by_max_length(ids, 10)
+    print(padded_idx)
+
+    tokens = vocabulary.convert_ids_to_tokens(padded_idx)
+    print(tokens)
+    return
+
+
+if __name__ == '__main__':
+    demo1()