seq2seq简单实现--在输入序列后添加1

import numpy as np
import tensorflow as tf
import functools

#参数设置
PAD = 0
EOS = 1

# embedding parameters
vocab_size = 10  #词典数量 约等于最后输出的数据库
input_embedding_size = 20  #embedding输入层大小 词的向量化的输入数据

# network parameters
encoder_hidden_units = 20
decoder_hidden_units = 20

# training parameters
batch_size = 100
max_batches = 3001 # 训练需要执行的batch的个数
batches_in_epoch = 1000


def gen_batch(inputs, max_seq_length=None):
    '''
    将inputs转换为numpy数组并将所有sequence用0填充到等长。
    参数
    -------
    inputs : (batch_size,seq_len)
    '''
    sequence_lengths = [len(seq) for seq in inputs] #用于获取每个序列的长度
    batch_size = len(inputs) #用于保存矩阵的行数，也就是batch——size
    if max_seq_length is None:
        max_seq_length = max(sequence_lengths)  #使用输入序列的最长序列长度作为长度限制
    # inputs对应的numpy数组，其中batch_size作为axis=0
    inputs_batch_major = np.zeros(shape=[batch_size, max_seq_length], dtype=np.int32) #初始为0随机化数组
    # seq:(seq_len,input_num)
    for i, seq in enumerate(inputs): #enumerate常用于循环中，用于将下标与数据分离 先分离每一行
        # element:input_num
        for j, element in enumerate(seq): #用于分离第二维的数据
            inputs_batch_major[i, j] = element #传入每一个数据
    # 将seq_len作为axis=0 因为后面需要time——step为第一维
    inputs_seq_major = inputs_batch_major.swapaxes(0, 1)
    return inputs_seq_major, max_seq_length #返回随机数列与序列长度

def random_sequences(length_from, length_to, vocab_lower, vocab_upper, batch_size):
    '''
    随机产生batch_size个sequences，
    其中sequences的长度介于[length_from,length_to],
    sequences中的值介于[vocab_lower,vocab_upper]
    '''
    if length_from > length_to: #错误异常判断
        raise ValueError('length_from > length_to')
    def random_length():
        '''
        随机产生介于[length_from,length_to]的整数
        '''
        if length_from == length_to:
            return length_from
        return np.random.randint(length_from, length_to + 1)

    while True:
        yield [np.random.randint(low=vocab_lower,
                              high=vocab_upper,
                              size=random_length()).tolist()  #生成batchsize组数据
            for _ in range(batch_size)
        ]

def next_feed(batches):
    '''
    用于train时，为sess产生feed_dict
    '''
    batch = next(batches) # 产生当前batch的数据
    encoder_inputs_, _ = gen_batch(batch) # 将该batch的数据处理为encoder期望的形式
    # decoder_inputs_是在原始sequence前拼接EOS
    decoder_inputs_, _ = gen_batch(
        [[EOS] + (sequence) for sequence in batch]
    )

    # decoder_targets_是在原始sequence后拼接EOS
    decoder_targets_, _ = gen_batch(
        [(sequence) + [EOS] for sequence in batch]
    )

    return {
        encoder_inputs: encoder_inputs_,
        decoder_inputs: decoder_inputs_,
        decoder_targets: decoder_targets_,
    }

# encoder_inputs:(batch_size,seq_len)
encoder_inputs = tf.placeholder(shape=[None,None], dtype=tf.int32, name='encoder_inputs')
# decoder_inputs:(batch_size,seq_len+1)
decoder_inputs = tf.placeholder(shape=[None,None], dtype=tf.int32, name='decoder_inputs')
# decoder_targets:(batch_size,seq_len+1)
decoder_targets = tf.placeholder(shape=[None,None], dtype=tf.int32, name='decoder_targets')

# embedding  用于将词的ID转化为向量用于输入到RNN中
lookup_table = tf.Variable(tf.random_normal([vocab_size,input_embedding_size],-1.,1.),dtype=tf.float32)
# eocoder_inputs_embedded:(batch_size,seq_len,input_embedding_size)
encoder_inputs_embedded = tf.nn.embedding_lookup(lookup_table,encoder_inputs)
decoder_inputs_embedded = tf.nn.embedding_lookup(lookup_table,decoder_inputs)
"""
函数：
tf.nn.embedding_lookup(

               params,

               ids,

               partition_strategy='mod',

               name=None,

              validate_indices=True,

              max_norm=None

)

参数说明：
params: 表示完整的嵌入张量，或者除了第一维度之外具有相同形状的P个张量的列表，表示经分割的嵌入张量
ids: 一个类型为int32或int64的Tensor，包含要在params中查找的id
partition_strategy: 指定分区策略的字符串，如果len（params）> 1，则相关。当前支持“div”和“mod”。 默认为“mod”
name: 操作名称（可选）
validate_indices:  是否验证收集索引
max_norm: 如果不是None，嵌入值将被l2归一化为max_norm的值

tf.nn.embedding_lookup()函数的用法主要是选取一个张量里面索引对应的元素
tf.nn.embedding_lookup(tensor,id)：即tensor就是输入的张量，id 就是张量对应的索引
tf.nn.embedding_lookup()就是根据input_ids中的id，寻找embeddings中的第id行。比如input_ids=[1,3,5]，则找出embeddings中第1，3，5行，组成一个tensor返回
embedding_lookup不是简单的查表，id对应的向量是可以训练的，训练参数个数应该是 category num*embedding size，也就是说lookup是一种全连接层

"""
# 定义encoder
encoder_cell = tf.contrib.rnn.LSTMCell(encoder_hidden_units)
encoder_outputs, encoder_final_state = tf.nn.dynamic_rnn(encoder_cell,
                                                         encoder_inputs_embedded,
                                                         dtype=tf.float32,
                                                         time_major=True) # time_major表示输入的axis=0轴为time(或者是seq_len)
del encoder_outputs # 将encoder的outputs丢弃，只将final_state传递给decoder

# 定义decoder
decoder_cell = tf.contrib.rnn.LSTMCell(decoder_hidden_units)
decoder_outputs,decoder_final_state = tf.nn.dynamic_rnn(decoder_cell,
                                                       decoder_inputs_embedded,
                                                       initial_state=encoder_final_state,
                                                       dtype=tf.float32,
                                                       time_major=True,
                                                       scope="plain_decoder")

# decoder_outputs是一个Tensor
#tf.contrib.layers.linear() = tf.contrib.layers.fully_connected()
decoder_logits = tf.contrib.layers.linear(decoder_outputs, vocab_size) #把输出转化为[batch_size,vocab_size]
decoder_prediction = tf.argmax(decoder_logits, 2)
stepwise_cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(
    labels=tf.one_hot(decoder_targets, depth=vocab_size, dtype=tf.float32),
    logits=decoder_logits)

loss = tf.reduce_mean(stepwise_cross_entropy)
#损失值
train_op = tf.train.AdamOptimizer().minimize(loss)
#Adam优化器

batches = random_sequences(length_from=3, length_to=8,
                           vocab_lower=2, vocab_upper=10,
                           batch_size=batch_size)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    loss_track = []
    for batch in range(max_batches):
        fd = functools.partial(next_feed, batches)() #每次循环产生一个batch的数据
        _, l = sess.run([train_op, loss], fd) #通过梯度下降训练，fd为字典
        loss_track.append(l)

        if batch == 0 or batch % batches_in_epoch == 0:
            print('batch {}'.format(batch))
            print('  minibatch loss: {}'.format(sess.run(loss, fd)))
            predict_ = sess.run(decoder_prediction, fd)
            for i, (inp, pred) in enumerate(zip(fd[encoder_inputs].T, predict_.T)):
                print('  sample {}:'.format(i + 1))
                print('    input     > {}'.format(inp))
                print('    predicted > {}'.format(pred))
                if i >= 2:
                    break

版权声明：本文为CSDN博主「BQW_」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/bqw18744018044/article/details/85220584