TFRecord存储维度（秩、rank、dimension）较多的数据以及创建Dataset的过程

TFRecord存储维度（秩、rank、dimension）较多的数据以及创建Dataset的过程

第一次接触tensorflow的Dataset和Estimator是在阅读BERT的特定任务的代码，原本用低阶API需要写很长的代码，在Estimator模式中简化了许多。
原本代码中的输入数据（即Dataset中的Example）的每个特征（即每个Example含有的Feature）的秩都为1，即矢量如v=[1,2,3]，其rank为1，shape为(3,)。而后续为了引入更多新的特征，比如charCNN或者charRNN来捕捉词语的形态特征，则需要在原来每个时间步的维度上再扩展一个维度，用于放置该时间步的字母。如[‘Are’, ’ you’, ‘OK’]，则输入为[[‘A’,‘r’,‘e’],[‘y’,‘o’,‘u’],[‘O’,‘K’]]，此时该Feature的rank为2，shape为(3,3)（此处将‘OK’ pad为长度为3的序列即可）。
那么这种多维度，rank>=2的形式的Feature应该怎么存储呢，后续又应该怎么读出到Dataset并解析呢。

保留该Feature的Shape信息后拉直（Flatten）Feature

这里借YJango大神的例子来举个栗子，然后再写写我的啦。

大神的例子

这里有三个example，每个example都有四类feature，分别是标量、向量、矩阵和张量，它们的shape分别为()，(3,)，(2,3)和(806,806,3)。

写入tfrecord

那应该怎么写入这些形态各异的特征呢？两种方法。

• 将其flatten成list形式，即rank=1的向量形式，然后按照list形式写入，如int64_list = tf.train.Int64List(value=输入)或float_list = tf.train.FloatList(value=输入)。
• 转成string类型：将张量用.tostring()转换成string类型，再用tf.train.Feature(bytes_list=tf.train.BytesList(value=[input.tostring()]))来存储。

这两种方法都会丢失数据的维度，因此需要将其存储以备后续使用或者提前将这些参数预设好即可。

# 打开一个tfrecord文件，准备进行写入
writer = tf.python_io.TFRecordWriter('%s.tfrecord' %'test') 
# 这里我们将会写3个样本，每个样本里有4个feature：标量，向量，矩阵，张量
for i in range(3):
    # 创建字典
    features={}
    # 写入标量，类型Int64，由于是标量，所以"value=[scalars[i]]" 变成list
    features['scalar'] = tf.train.Feature(int64_list=tf.train.Int64List(value=[scalars[i]]))
    
    # 写入向量，类型float，本身就是list，所以"value=vectors[i]"没有中括号
    features['vector'] = tf.train.Feature(float_list = tf.train.FloatList(value=vectors[i]))
    
    # 写入矩阵，类型float，本身是矩阵，一种方法是将矩阵flatten成list
    features['matrix'] = tf.train.Feature(float_list = tf.train.FloatList(value=matrices[i].reshape(-1)))
    # 然而矩阵的形状信息(2,3)会丢失，需要存储形状信息，随后可转回原形状
    features['matrix_shape'] = tf.train.Feature(int64_list = tf.train.Int64List(value=matrices[i].shape))
    
    # 写入张量，类型float，本身是三维张量，另一种方法是转变成字符类型存储，随后再转回原类型
    features['tensor'] = tf.train.Feature(bytes_list=tf.train.BytesList(value=[tensors[i].tostring()]))
    # 存储丢失的形状信息(806,806,3)
    features['tensor_shape'] = tf.train.Feature(int64_list = tf.train.Int64List(value=tensors[i].shape))
    
    # 将存有所有feature的字典送入tf.train.Features中
    tf_features = tf.train.Features(feature= features)
    # 再将其变成一个样本example
    tf_example = tf.train.Example(features = tf_features)
    # 序列化该样本
    tf_serialized = tf_example.SerializeToString()
    # 写入一个序列化的样本
    writer.write(tf_serialized)
    # 由于上面有循环3次，所以到此我们已经写了3个样本
 # 关闭文件    
writer.close()

建立Datasets

由于从tfrecord文件中导入的样本是刚才写入的tf_serialized序列化样本，所以我们需要对每一个样本进行解析。
这里就用dataset.map(parse_function)来对dataset里的每个样本进行相同的解析操作。而parse_function的解析过程几乎就是上述过程的逆过程。此外，我们还能在parse_function里进行很多其他操作，比如转换数据的dtype，给每个数据加入噪音等等。总之，在parse_function内，我们处理的对象就是一个序列化后的serialized_example，我们要对serialized_example进行解码获得example，然后返回这个example。
其解析函数的写法为：

def parse_function(example_proto):
    # 只接受一个输入：example_proto，也就是序列化后的样本tf_serialized
    dics = {# 这里没用default_value，随后的都是None
            'scalar': tf.FixedLenFeature(shape=(), dtype=tf.int64, default_value=None), 
             
            # vector的shape刻意从原本的(3,)指定成(1,3)
            'vector': tf.FixedLenFeature(shape=(1,3), dtype=tf.float32), 
            
            # 因为这里还不知道matrix的shape，所以使用 VarLenFeature来解析。
            'matrix': tf.VarLenFeature(dtype=dtype('float32')), 
            'matrix_shape': tf.FixedLenFeature(shape=(2,), dtype=tf.int64), 
            
            # tensor在写入时 使用了toString()，shape是()
            # 但这里的type不是tensor的原type，而是字符化后所用的tf.string，随后再回转成原tf.uint8类型
            'tensor': tf.FixedLenFeature(shape=(), dtype=tf.string), 
            'tensor_shape': tf.FixedLenFeature(shape=(3,), dtype=tf.int64)
            }
            
    # 把序列化样本和解析字典送入函数里得到解析的样本
    parsed_example = tf.parse_single_example(example_proto, dics)
    # 解码字符
    parsed_example['tensor'] = tf.decode_raw(parsed_example['tensor'], tf.uint8)
    # 稀疏表示 转为 密集表示
    parsed_example['matrix'] = tf.sparse_tensor_to_dense(parsed_example['matrix'])
    # 转变matrix形状
    parsed_example['matrix'] = tf.reshape(parsed_example['matrix'], parsed_example['matrix_shape'])
    # 转变tensor形状
    parsed_example['tensor'] = tf.reshape(parsed_example['tensor'], parsed_example['tensor_shape'])
    # 返回所有feature
    return parsed_example

此处如果我们有matrix的shape的一些信息，就并不需要用VarLenFeature进行解析，可以直接将matrix的shape中每个数相乘即可得到flatten后的matrix的list的信息，即’matrix’: tf.FixedLenFeature(shape=[matrix.shape()[0]*matrix.shape()[1]],dtype=dtype(‘float32’))。
写好解析函数以后，将这个解析函数作为dataset的map方法的输入即可。
剩下的batch，shuffle等操作就不再赘述了。建立迭代器的操作有这篇博客讲得很好了。

我的破例子

def filed_based_convert_examples_to_features(
        examples, tokenizer, output_file):
    """
    :param examples:
    :param tokenizer:
    :param output_file:
    :param mode:
    :return: number of small example
    """
    num_examples = 0
    writer = tf.python_io.TFRecordWriter(output_file)
    # 遍历训练数据
    for (ex_index, example) in enumerate(examples):
        # 对于每一个训练样本,
        feature_list = convert_single_example(example, tokenizer)
        num_examples += len(feature_list)

        def create_int_feature(values):
            f = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))
            return f

        def flatten(tensor):
            return sum(tensor, [])

        for f in feature_list:
            if num_examples%5000 == 0:
                tf.logging.info("Writing example %d of %d" % (num_examples, len(examples)))
            features = collections.OrderedDict()
            # f.input_ids，f.input_mask，f.segment_ids，f.tag_ids为向量，即形如[1,2,3,4...]，
            # 其shape为(max_seq_length,)
            features["input_ids"] = create_int_feature(f.input_ids) 
            features["input_mask"] = create_int_feature(f.input_mask) 
            features["segment_ids"] = create_int_feature(f.segment_ids) 
            # f.char_ids为矩阵，形如[[1,2,3],[4,5,6],[7,8,9]],
            # 其shape为(max_seq_length, max_char_length)
            # 因此要先将其flatten为向量，shape为(max_seq_length*max_char_length,)，再转化为feature
            features["char_ids"] = create_int_feature(flatten(f.char_ids)) 
            features["tag_ids"] = create_int_feature(f.tag_ids) # 为向量
            # 最后放进字典里，传入tf.train.Example
            tf_example = tf.train.Example(features=tf.train.Features(feature=features))
            writer.write(tf_example.SerializeToString())
    writer.close()
    return num_examples


def file_based_input_fn_builder(input_file, seq_length, char_length, is_training, drop_remainder):
	# 与上述相反的解码过程
    name_to_features = {
        "input_ids": tf.FixedLenFeature([seq_length], tf.int64),
        "input_mask": tf.FixedLenFeature([seq_length], tf.int64),
        "segment_ids": tf.FixedLenFeature([seq_length], tf.int64),
        "char_ids": tf.FixedLenFeature([seq_length * char_length], tf.int64),
        "tag_ids": tf.FixedLenFeature([seq_length], tf.int64),
    }

    def _decode_record(record, name_to_features):
        example = tf.parse_single_example(record, name_to_features)
        for name in list(example.keys()):
            t = example[name]
            # 将int64转为int32，因为上面只有tf.train.Int64List而没有int32
            if t.dtype == tf.int64:
                t = tf.to_int32(t)
            example[name] = t
        # char_ids将其reshape回来即可
        example["char_ids"] = tf.reshape(example["char_ids"],
                                         shape=(seq_length, char_length))
        return example

    def input_fn(params):
        batch_size = params["batch_size"]
        d = tf.data.TFRecordDataset(input_file)
        if is_training:
            d = d.repeat()
            d = d.shuffle(buffer_size=100)
        d = d.apply(tf.contrib.data.map_and_batch(
            lambda record: _decode_record(record, name_to_features),
            batch_size=batch_size,
            drop_remainder=drop_remainder
        ))
        return d

    return input_fn

第二个函数返回的是一个函数的闭包，主要用于estimator模式下的数据输入。这是本人基于BERT做NER改进的charCNN-BERT-CRF模型，有兴趣的可以去我GitHub看看哈。

写这篇博客的初衷

为啥要写这篇博客呢？因为我在解决这个问题时走了一个弯路，就是使用了FeatureList。即将每个单词的字母切分作为Feature，然后添加为FeatureList的元素。然而FeatureList的解码相对比较复杂难写，尽管程序没有报错，但是在运行时，却显示读出的样本数为0，即无法读出样本，一个样本都没有进入网络。当然有了前面提到的方法，这个FeatureList的作用到底大不大呢，应用广不广呢，Feature和它相比有什么做不到的地方吗（我好像看到目标识别好像有用到这个作为data pipeline）？这几天如果有时间我再根据这篇博客介绍的方法试试，到时再更新啦！也欢迎各位大佬对我进行指正！
今晚对Featurelist的方法实现了一下，发现也是可以实现同样的功能，代码如下：

def filed_based_convert_examples_to_features(
        examples, tokenizer, output_file):
    """
    :param examples:
    :param tokenizer:
    :param output_file:
    :param mode:
    :return: number of small example
    """
    num_examples = 0
    writer = tf.python_io.TFRecordWriter(output_file)
    # 遍历训练数据
    for (ex_index, example) in enumerate(examples):
        # 对于每一个训练样本,
        example_list = convert_single_example(example, tokenizer)
        num_examples += len(example_list)

        def create_int_feature(values):
            f = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))
            return f
		# 新增一个转化featurelist的方法
        def create_feature_list(values_list):
            fl = tf.train.FeatureList(
                feature=[tf.train.Feature(int64_list=tf.train.Int64List(value=values)) for values in values_list])
            return fl

        def flatten(tensor):
            return sum(tensor, [])

        for f in example_list:
            if num_examples%5000 == 0:
                tf.logging.info("Writing example %d of %d" % (num_examples, len(examples)))
            features = collections.OrderedDict()
            # 给featurelists也申请一个字典
            features_list = collections.OrderedDict()
            features["input_ids"] = create_int_feature(f.input_ids)
            features["input_mask"] = create_int_feature(f.input_mask)
            features["segment_ids"] = create_int_feature(f.segment_ids)
            features["tag_ids"] = create_int_feature(f.tag_ids)
            # 这里转化为featurelist，但是感觉这样的写法，其实也没有方便多少啦！
            # 个人感觉featurelist的用法应该不是单纯这样用的，不然就这样最多也只是能转个二维，有啥意思呢？
            # 欢迎各位指正啦
            features_list["char_ids"] = create_feature_list(f.char_ids)
            # 这里要用SequenceExample啦！同理分别将features和featurelists装进context和feature_lists
            tf_example = tf.train.SequenceExample(context=tf.train.Features(feature=features),
                                                  feature_lists=tf.train.FeatureLists(feature_list=features_list))
            writer.write(tf_example.SerializeToString())
    writer.close()
    return num_examples


def file_based_input_fn_builder(input_file, seq_length, char_length, is_training, drop_remainder):
    name_to_features = {
        "input_ids": tf.FixedLenFeature([seq_length], tf.int64),
        "input_mask": tf.FixedLenFeature([seq_length], tf.int64),
        "segment_ids": tf.FixedLenFeature([seq_length], tf.int64),
        "tag_ids": tf.FixedLenFeature([seq_length], tf.int64),
    }
    # featurelist的解码
    name_to_features_list = {
        "char_ids": tf.FixedLenSequenceFeature([char_length], tf.int64),
    }

    def _decode_record(record, name_to_features, name_to_features_list):
    	# 这里有两个返回值，一个返回feature即context的内容，另一份是featurelist即sequence的内容
        context_example, sequence_example = tf.parse_single_sequence_example(record,
                                                   context_features=name_to_features,
                                                   sequence_features=name_to_features_list)
        for name in list(context_example.keys()):
            t = context_example[name]
            if t.dtype == tf.int64:
                t = tf.to_int32(t)
            context_example[name] = t

        for name in list(sequence_example.keys()):
            tl = sequence_example[name]
            if tl.dtype == tf.int64:
                tl = tf.to_int32(tl)
            sequence_example[name] = tl

        return context_example, sequence_example

    def input_fn(params):
        batch_size = params["batch_size"]
        d = tf.data.TFRecordDataset(input_file)
        if is_training:
            d = d.repeat()
            d = d.shuffle(buffer_size=100)
        d = d.apply(tf.contrib.data.map_and_batch(
            lambda record: _decode_record(record, name_to_features, name_to_features_list),
            batch_size=batch_size,
            drop_remainder=drop_remainder
        ))
        return d

    return input_fn

def main(_):
    tf.logging.set_verbosity(tf.logging.INFO)
    train_data_dir = ['training-PHI-Gold-Set2']
    wordpiece_vocab = tokenization_ner.build_wordpiece_vocab(root_path, bert_path, 'vocab.txt')
    wptokenizer = tokenization_ner.WPTokenizer(wordpiece_vocab, FLAGS.max_seq_length, FLAGS.max_char_length)
    train_file = os.path.join(FLAGS.output_dir, "train.tf_record")
    if not os.path.exists(os.path.join(FLAGS.output_dir, "train.tf_record")):
        train_examples = load_examples(train_data_dir)
        num_train_examples = filed_based_convert_examples_to_features(train_examples, wptokenizer, train_file)
    train_input_fn = file_based_input_fn_builder(
        input_file=train_file,
        seq_length=FLAGS.max_seq_length,
        char_length=FLAGS.max_char_length,
        is_training=True,
        drop_remainder=True)

    params = {}
    params["batch_size"] = FLAGS.train_batch_size
    dataset = train_input_fn(params)

    iterator = dataset.make_one_shot_iterator()

    with tf.Session() as sess:
        for _ in range(1):
            try:
                context, sequence = sess.run(iterator.get_next())
                print(sequence['char_ids'])
            except tf.errors.OutOfRangeError:
                break

最后也正确输出啦。。。