产品
我打算基于lstm构建一个分词系统，通过这个例子来学习下TensorFlow中如何训练循环递归神经网络。我们将从最粗糙的版本开始搭建这个小系统，然后一步步优化其中的每一部分，包括网络架构的优化，数据处理的优化，甚至整个代码架构的优化。希望想我一样的入门选手看到其中的每一步实现以及如何去优化。
关于LSTM网络的介绍，可以看官网推荐的一篇博客，写的实在是太棒了 http://colah.github.io/posts/2015-08-Understanding-LSTMs
另外这篇翻译也很赞啊 http://www.jianshu.com/p/9dc9f41f0b29，这里不在详述。
我们第一个版本的模型来自官网的tutorials中Recurrent Neural Networks部分内容，官网的数据并不利于我们去直接感受模型训练的带来的结果，所以后来我想了下用它来实现一个中文分词，可能更有利于初学者去直观的感受。第一个版本会我写的很粗糙，主要是为了理解在TensorFlow中如何搭建LSTM网络。
我对官网中的例子用我自己更喜欢的结构重写了下。 首先我们来看下如何搭建这个模型。开始我把模型部分代码主要由inference()，loss()和training()三部分构成，inference()部分负责模型搭建，loss()负责计算损失，为优化做准备，training()负责优化部分，主要是对损失函数应用梯度下降，更新参数。我把上面三部分写封装一个类里面。后来发现这样实现会存在些问题，然后又把inference()的实现直接放在了类的init()函数里面。下面先看下模型的整体实现，
登录后复制
class ptb_lstm(): def __init__(self,config): ... def loss(self): .... def train(self):
....1.2.3.4.5.6.7.8.这里，我们在init()中传了一个config类，这个config主要是一些模型参数，大致形式是下面这样，这篇笔记就不详讲了
登录后复制
class config(): '''参数配置类''' init_scale = 0.1 learning_rate = 1.0
max_grad_norm = 5
num_layers = 2
hidden_size = 200
keep_prob = 1.0
lr_decay = 0.5
batch_size = 50
num_steps = 50
vocab_size = 3000
output_size = 3
learningrate = 0.51.2.3.4.5.6.7.8.9.10.11.12.13.14.好了，接下来我们先看init()部分
登录后复制
class lstm_model(): def __init__(self, config): ''' :param config:config类，一些训练参数设置
''' self.config = config self.x = tf.placeholder(tf.int32, shape=(config.batch_size,
config.num_steps)) self.y = tf.placeholder(tf.int32, shape=(config.batch_size, config.num_steps))
def lstm_cell(): #构建lstm基本单元 return tf.contrib.rnn.BasicLSTMCell(
self.config.hidden_size, forget_bias=0.0, state_is_tuple=True) attn_cell = lstm_cell
if config.keep_prob < 1: #如果config.keep_prob参数小于1,对lstm单元进行dropout，防止过拟合
def attn_cell(): return tf.contrib.rnn.DropoutWrapper( lstm_cell(),
output_keep_prob=config.keep_prob) cell = tf.contrib.rnn.MultiRNNCell( [attn_cell() for
_ in range(config.num_layers)], state_is_tuple=True) #构建多层的lstm，config.num_layers是层数参数
self._initial_state = cell.zero_state(self.config.batch_size, tf.float32)
#初始化lstm的state
with tf.device("/cpu:0"): embedding = tf.get_variable( "embedding",
[self.config.vocab_size, self.config.hidden_size], dtype=tf.float32)
inputs = tf.nn.embedding_lookup(embedding,self.x) #词嵌入 outputs = []
state = self._initial_state with tf.variable_scope("RNN"):
for time_step in range(self.config.num_steps):
if time_step > 0: tf.get_variable_scope().reuse_variables()
(cell_output, state) = cell(inputs[:, time_step, :], state)
outputs.append(cell_output)
#前向传播，计算每个单元的cell_output和state，把cell_output添加到outputs，把state传递到下个单元，
最终outputs的为(config.num_steps,config.batch_size,config.hidden_size)
output = tf.reshape(tf.concat(axis=1, values=outputs), [-1, self.config.hidden_size])
#output的形状为(config.num_steps*config.batch_size,config.hedden_size)
softmax_w = tf.get_variable(
"softmax_w", [self.config.hidden_size, self.config.output_size], dtype=tf.float32)
softmax_b = tf.get_variable("softmax_b", [self.config.output_size], dtype=tf.float32)
self.logits = tf.matmul(output, softmax_w) + softmax_b
#得到最终的网络输出logits形状为(config.num_steps*config.batch_size,config.output_size)
1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.
40.41.42.43.44.45.46.47.48.49.50.51.接着是loss(self,logits)
登录后复制
def loss(self): logits = self.logits
loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example( [logits],
[tf.reshape(self.y, [-1])],
[tf.ones([self.config.batch_size * self.config.num_steps], dtype=tf.float32)])
# 交叉熵损失函数，下一篇专门讲下tensorflow中的几个损失函数的实现
cost = tf.reduce_sum(loss) / self.config.batch_size1.2.3.4.5.6.7.8.9.最后是后向传播参数更新部分training(self)
登录后复制
def training(self): loss = self.loss() tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(loss, tvars),
self.config.max_grad_norm)
optimizer = tf.train.GradientDescentOptimizer(self.config.learningrate)
#优化器 train_op = optimizer.apply_gradients( zip(grads, tvars),
global_step=tf.contrib.framework.get_or_create_global_step())
#梯度下降 return train_op1.2.3.4.5.6.7.8.9.10.11.12.13.14.简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。 https://www.jianshu.com/p/142b4358aaf9
上一节我们介绍了我们的模型部分，这一节来介绍下我们的数据来源和数据预处理。对初学者可能常常面临的问题的是模型的输入到底是怎样的，例如，在rnn可以处理任意长度的句子，所以很多初学者可能会认为是不是在TensorFlow中输入不需要特殊处理。理论上rnn是可以处理任意长度的句子，但在工程实现上考虑到效率等一些列问题，TensorFlow中的rnn（包括它的变形，lstm，gru...）需要把不同长度的句子pading到同一个长度，一种是把所有句子都处理成同一个长度，另一种是我们只需要在同一个batch中的句子同一个长度。本节采用第一种。
这里我们自己构造了一份训练数据，我随意找了一份京东评论数据，你也可以采用其他的文本数据。然后利用jieba分词对这些文本进行分词。例如，有这样一句话，s1 = “迪士尼发行了四部票房超过10亿美元的电影”，我们对s1分词后成为s1_seg = ['迪士尼', '发行', '了', '电影']，其中，“迪士尼”就是一个词，我们把它处理成['B','I','I']，‘B’代表词的开始，‘I’代表词的中间。这样s1就可以标记为s1_tag=['B','I','I','B','I','B','B','I']，这样我们就可以得到我们的训练数据。注意，jieba本身就可能分错，我们这里只是想看下我们的模型能不能学习到训练数据的分布。
刚才我们已经得到我们的训练数据，现在我们要把它处理成符合输入要求的数据格式。为了简单，我这里把所以数据都处理成同样长度的序列（上一章中我们构建的模型就是要求的所有的序列长度一样）。由于在训练的时，我们需要在数据上不断的迭代更新参数。这里需要把数据处理成不同的batch，然后在每个batch上迭代。这里我们构造了一个类，这个类有一个next_batch方法。通过这个方法可以不断的产生batch_size的训练数据。
登录后复制
class DataSet(object): def __init__(self,x_data,y_data,): #这个类主要用于不断产生训练数据
self._x_data = np.array(x_data) self._y_data = np.array(y_data)
self._epochs_completed = 0 self._index_in_epoch = 0
self._num_examples = len(x_data) @property def x_data(self):
return self._x_data @property def y_data(self): return self._y_data
@property def num_examples(self): return self._num_examples @property
def epochs_completed(self): return self._epochs_completed
def next_batch(self, batch_size, shuffle=True): """返回下一个`batch_size`数据"""
start = self._index_in_epoch # 第一个epoch时做乱序处理
if self._epochs_completed == 0 and start == 0 and shuffle:
perm0 = np.arange(self._num_examples) np.random.shuffle(perm0)
self._x_data = self.x_data[perm0] self._y_data = self.y_data[perm0]
# 进入到下一个epoch if start + batch_size > self._num_examples:
# Finished epoch self._epochs_completed += 1
# Get the rest examples in this epoch rest_num_examples = self._num_examples - start
x_rest_part = self._x_data[start:self._num_examples]
y_rest_part = self._y_data[start:self._num_examples]
# 数据乱序处理 if shuffle: perm = np.arange(self._num_examples)
np.random.shuffle(perm) self._x_data = self._x_data[perm]
self._y_data = self._y_data[perm] # 开始下一个epoch start = 0
self._index_in_epoch = batch_size - rest_num_examples end = self._index_in_epoch
x_new_part = self._x_data[start:end] y_new_part = self._y_data[start:end]
return np.concatenate((x_rest_part, x_new_part), axis=0), np.concatenate(
(y_rest_part, y_new_part), axis=0) else: self._index_in_epoch += batch_size
end = self._index_in_epoch
return self._x_data[start:end], self._y_data[start:end]def word_to_id(dict_data):
#遍历所以的中文句子里的字符，建立一个Vocabulary，通过字符的频次把每个字符映射到一个数字
counter = collections.Counter(''.join(dict_data.keys()))
count_pairs = sorted(counter.items(), key=lambda x: (-x[1], x[0]))
words, _ = list(zip(*count_pairs)) word_id = dict(zip(words, range(3, len(words) + 3)))
word_id['B'] = 1 word_id['I'] = 2 return word_iddef datas(dict_data,num_step):#读取数据
x_data = [] y_data = [] word_id = word_to_id(dict_data) for line in dict_data:
x_list = [word_id[word] for word in list(line)][:num_step]
y_list = [word_id[word] for word in dict_data[line]][:num_step]
x_len = len(x_list) y_len = len(y_list) assert x_len == y_len
if x_len<num_step: x_list.extend([0]*(num_step-x_len))
y_list.extend([0]*(num_step-y_len)) x_data.append(x_list) y_data.append(y_list)
return x_data,y_datadef read_data_sets(fileName,num_step):#通过调用这个函数不断的产生next batch的训练数据
with open(fileName) as f: dict_data = json.load(f) x_data, y_data = datas(dict_data, num_step)
return DataSet(x_data, y_data)1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30
.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.50.51.52.53.54.55.56.57.58.59.60.61.62.63.64.65.66.
67.68.69.70.71.72.73.74.75.76.77.78.79.80.81.82.83.84.85.86.87.88.89.90.91.92.93.94.95.96.97.98.99.100.101.102
.103.104.通过调用read_data_sets来产生训练数据，注意这里的参数dict_data参数指的是，key是字符串，例如前面的s1，value是该字符串的标记，例如s1的标记是s1_tag。
免责声明：本文系网络转载或改编，未找到原创作者，版权归原作者所有。如涉及版权，请联系删
155-2731-8020
