数据模块使用说明

    ...
    class Vocabulary(object):
    """Vocabulary"""
    def __init__(self, vocab_path, unk_token):
        """
        :param vocab_path: 词表地址，必填
        :param unk_token: unk默认的token，必填
        """
        if not vocab_path:
            raise ValueError("vocab_path can't be None")

        self.vocab_path = vocab_path
        self.unk_token = unk_token
        self.vocab_dict, self.id_dict = self.load_vocab()
        self.vocab_size = len(self.id_dict)

    def load_vocab(self):
        """
        :return:
        """
        vocab_dict = collections.OrderedDict()
        id_dict = collections.OrderedDict()
        file_vocab = open(self.vocab_path)
        for num, line in enumerate(file_vocab):
            items = convert_to_unicode(line.strip()).split("\t")
            if len(items) > 2:
                break
            token = items[0]
            if len(items) == 2:
                index = items[1]
            else:
                index = num
            token = token.strip()

            vocab_dict[token] = int(index)
            id_dict[index] = token

        return vocab_dict, id_dict

    def add_reserve_id(self):
        """添加预留的一些id
        :return:
        """
        pass

    def convert_tokens_to_ids(self, tokens):
        """
        :param tokens:
        :return:
        """
        output = []
        UNK = self.vocab_dict[self.unk_token]
        for item in tokens:
            output.append(self.vocab_dict.get(item, UNK))
        return output

    def convert_ids_to_tokens(self, ids):
        """
        :param ids:
        :return:
        """
        output = []
        for item in ids:
            output.append(self.id_dict.get(item, self.unk_token))
        return output

    def get_vocab_size(self):
        """获取词表大小
        :return:
        """
        return len(self.id_dict)

    def covert_id_to_token(self, id):
        """
        :param id:
        :return: token
        """
        return self.id_dict.get(id, self.unk_token)

    def covert_token_to_id(self, token):
        """
        :param token:
        :return: id
        """
        UNK = self.vocab_dict[self.unk_token]
        return self.vocab_dict.get(token, UNK)
    ...

    ...
@RegisterSet.tokenizer.register
class Tokenizer(object):
    """Tokenizer"""

    def __init__(self, vocab_file, split_char=" ", unk_token="[UNK]", params=None):
        """
        :param vocab_file: 词表文件路径
        :param split_char: 明文分隔符，默认是空格
        :param unk_token: unk 对应的token，默认是[UNK]
        :param params: 个别tokenizer自己用到的额外参数，dict类型
        """
        self.vocabulary = Vocabulary(vocab_file, unk_token)
        self.split_char = split_char
        self.unk_token = unk_token
        self.params = params

    def tokenize(self, text):
        """
        :param text:
        :return: tokens, list类型
        """
        raise NotImplementedError

    def convert_tokens_to_ids(self, tokens):
        """
        :param tokens:
        :return:
        """
        raise NotImplementedError

    def convert_ids_to_tokens(self, ids):
        """
        :param ids:
        :return:
        """
        raise NotImplementedError

    def covert_id_to_token(self, id):
        """
        :param id:
        :return: token
        """
        return self.vocabulary.covert_id_to_token(id)

    def covert_token_to_id(self, token):
        """
        :param token:
        :return: id
        """
        return self.vocabulary.covert_token_to_id(token)
    ...

    ...
    
@RegisterSet.field_reader.register
class BaseFieldReader(object):
    """BaseFieldReader: 作用于field的reader，主要是定义py_reader的格式，完成id序列化和embedding的操作
    """
    def __init__(self, field_config):
        self.field_config = field_config
        self.tokenizer = None  # 用来分词，需要各个子类实现
        self.token_embedding = None  # 用来生成embedding向量，需要各个子类实现

    def init_reader(self):
        """ 初始化reader格式
        :return: reader的shape[]、type[]、level[]
        """
        raise NotImplementedError

    def convert_texts_to_ids(self, batch_text):
        """ 明文序列化
        :param:batch_text
        :return: id_list
        """
        raise NotImplementedError

    def get_field_length(self):
        """获取当前这个field在进行了序列化之后，在field_id_list中占多少长度
        :return:
        """
        raise NotImplementedError

    def structure_fields_dict(self, fields_id, start_index, need_emb=True):
        """静态图调用的方法，生成一个dict， dict有两个key:id , emb. id对应的是pyreader读出来的各个field产出的id，emb对应的是各个
        field对应的embedding
        :param fields_id: pyreader输出的完整的id序列
        :param start_index:当前需要处理的field在field_id_list中的起始位置
        :param need_emb:是否需要embedding（预测过程中是不需要embedding的）
        :return:
        """
        raise NotImplementedError
    ...

    ...
    
@RegisterSet.data_set_reader.register
class BaseDataSetReader(object):
    """BaseDataSetReader:将样本中数据组装成一个py_reader, 向外提供一个统一的接口。
    核心内容是读取明文文件，转换成id，按py_reader需要的tensor格式灌进去，然后通过调用run方法让整个循环跑起来。
    py_reader拿出的来的是lod-tensor形式的id，这些id可以用来做后面的embedding等计算。
    """
    def __init__(self, name, fields, config):
        self.name = name
        self.fields = fields
        self.config = config  # 常用参数，batch_size等，ReaderConfig类型变量
        self.paddle_py_reader = None
        self.current_example = 0
        self.current_epoch = 0
        self.num_examples = 0

    def create_reader(self):
        """ 
        必须选项，否则会抛出异常。
        用于初始化self.paddle_py_reader。
        ``self.paddle_py_reader = fluid.layers.py_reader(
            capacity=capacity,
            shapes=shapes,
            name=self.name,
            dtypes=types,
            lod_levels=levels,
            use_double_buffer=True)
        ``
        :return:None
        """
        raise NotImplementedError

    def instance_fields_dict(self):
        """
        必须选项，否则会抛出异常。
        实例化fields_dict, 调用pyreader，得到fields_id, 视情况构造embedding，然后结构化成dict类型返回给组网部分。
        :return:dict
                {"field_name":
                    {"RECORD_ID":
                        {"SRC_IDS": [ids],
                         "MASK_IDS": [ids],
                         "SEQ_LENS": [ids]
                        }
                    }
                }
        实例化的dict，保存了各个field的id和embedding(可以没有，是情况而定), 给trainer用.
        
        """
        raise NotImplementedError

    def data_generator(self):
        """
        必须选项，否则会抛出异常。
        数据生成器：读取明文文件，生成batch化的id数据，绑定到py_reader中
        :return:list
                [[src_ids],
                 [mask_ids],
                 [seq_lens]
                ]
        """
        raise NotImplementedError


    def convert_fields_to_dict(self, field_list, need_emb=False):
        """instance_fields_dict一般调用本方法实例化fields_dict，保存各个field的id和embedding(可以没有，是情况而定),
        当need_emb=False的时候，可以直接给predictor调用
        :param field_list:
        :param need_emb:
        :return: dict
        """
        raise NotImplementedError

    def run(self):
        """
        配置py_reader对应的数据生成器，并启动
        :return:
        """
        if self.paddle_py_reader:
            self.paddle_py_reader.decorate_tensor_provider(self.data_generator())
            self.paddle_py_reader.start()
            logging.info("set data_generator and start.......")
        else:
            raise ValueError("paddle_py_reader is None")

    def stop(self):
        """
        :return:
        """
        if self.paddle_py_reader:
            self.paddle_py_reader.reset()
        else:
            raise ValueError("paddle_py_reader is None")

    def get_train_progress(self):
        """Gets progress for training phase."""
        return self.current_example, self.current_epoch

    def get_num_examples(self):
        """get number of example"""
        return self.num_examples

    ...

    ...
    
class DataSet(object):
    """DataSet"""
    def __init__(self, params_dict):
        """"""
        self.train_reader = None
        self.test_reader = None
        self.dev_reader = None
        self.predict_reader = None

        self.params_dict = params_dict

    def build(self):
        """ init readers
        :return:
        """

    ...

.                                                        
├── data                                                                  ## 数据读取、嵌入部分
│   ├── __init__.py
│   ├── data_set.py                                                       ## 区分训练与评估的与不同域的reader                                                    
│   ├── data_set_reader
│   │   ├── __init__.py                                                 
│   │   ├── base_dataset_reader.py                                        ## 基类，读文件、组batch
│   │   ├── basic_dataset_reader.py                                     
│   │   └── ...
│   ├── field.py                                                          ## 域对象的定义
│   ├── field_reader
│   │   ├── __init__.py                                                 
│   │   ├── base_field_reader.py                                          ## 基类
│   │   ├── custom_text_field_reader.py                                   ## 通用文本reader basic + mask(用于区分padding), 非ernie网络通用
│   │   ├── ernie_classification_field_reader.py                          ## ernie句对分类reader
│   │   ├── ernie_seqlabel_label_field_reader.py                          ## ernie序列标注标签域reader                       
│   │   ├── ernie_text_field_reader.py                                    ## ernie双塔文本域reader
│   │   ├── generate_label_field_reader.py                                ## 文本生成标签域reader
│   │   ├── scalar_array_field_reader.py                                  ## 数值类型数组reader，需要指定整型还是浮点型，支持转为id的文本数据
│   │   ├── scalar_field_reader.py                                        ## 数值类型标量reader，需要指定整型还是浮点型
│   │   └── text_field_reader.py                                          ## 文本reader 只输出padding后的id length（区分非padding）
│   ├── reader_config.py                                                   ## 一些配置参数，如batch-size、epoch、shuffle等
│   ├── tokenizer
│   │   ├── __init__.py 
│   │   ├── tokenizer.py                                                  ## 基类
│   │   ├── custom_tokenizer.py                                           ## 分词用tokenizer, 对于已用空格分好词的文本                                           
│   │   ├── tokenization_spm.py											 ## 针对英文数据集的ernie pre-train任务的tokenizer， 用户不需要分词
│   │   ├── tokenization_utils.py                                         ## tokenizer过程中会用到的工具方法，如unicode转换、空格清理等
│   │   └── tokenization_wp.py                                            ## 针对中文数据集的ernie任务用到的tokenizer，包括FullTokenzier、WordPiece、SentencePiece等
│   ├── util_helper.py                                                    ## 数据处理过程中的一些工具方法，比如添加padding、添加mask。
│   ├── vocabulary.py                                                     ## 词表模块
├──