http://blog.csdn.net/u010223750/article/details/53334313?locationNum=7&fps=1

引言

學習一段時間的tensor flow之后，想找個項目試試手，然后想起了之前在看Theano教程中的一個文本分類的實例，這個星期就用tensorflow實現了一下，感覺和之前使用的theano還是有很大的區別，有必要總結mark一下

模型說明

這個分類的模型其實也是很簡單，主要就是一個單層的LSTM模型，當然也可以實現多層的模型，多層的模型使用Tensorflow尤其簡單，下面是這個模型的圖?
?
簡單解釋一下這個圖，每個word經過embedding之后，進入LSTM層，這里LSTM是標準的LSTM，然后經過一個時間序列得到的t個隱藏LSTM神經單元的向量，這些向量經過mean pooling層之后，可以得到一個向量h，然后緊接著是一個簡單的邏輯斯蒂回歸層（或者一個softmax層）得到一個類別分布向量。?
公式就不一一介紹了，因為這個實驗是使用了Tensorflow重現了Theano的實現，因此具體的公式可以參看LSTM Networks for Sentiment Analysis這個鏈接。

tensorflow實現

鄙人接觸tensor flow的時間不長，也是在慢慢摸索，但是因為有之前使用Theano的經驗，對于符號化編程也不算陌生，因此上手Tensorflow倒也容易。但是感覺tensorflow還是和theano有著很多不一樣的地方，這里也會提及一下。?
代碼的模型的主要如下：

import tensorflow as tf import numpy as npclass RNN_Model(object):def __init__(self,config,is_training=True):self.keep_prob=config.keep_probself.batch_size=tf.Variable(0,dtype=tf.int32,trainable=False) num_step=config.num_step self.input_data=tf.placeholder(tf.int32,[None,num_step]) self.target = tf.placeholder(tf.int64,[None]) self.mask_x = tf.placeholder(tf.float32,[num_step,None]) class_num=config.class_num hidden_neural_size=config.hidden_neural_size vocabulary_size=config.vocabulary_size embed_dim=config.embed_dim hidden_layer_num=config.hidden_layer_num self.new_batch_size = tf.placeholder(tf.int32,shape=[],name="new_batch_size") self._batch_size_update = tf.assign(self.batch_size,self.new_batch_size) #build LSTM network lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_neural_size,forget_bias=0.0,state_is_tuple=True) if self.keep_prob<1: lstm_cell = tf.nn.rnn_cell.DropoutWrapper( lstm_cell,output_keep_prob=self.keep_prob ) cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell]*hidden_layer_num,state_is_tuple=True) self._initial_state = cell.zero_state(self.batch_size,dtype=tf.float32) #embedding layer with tf.device("/cpu:0"),tf.name_scope("embedding_layer"): embedding = tf.get_variable("embedding",[vocabulary_size,embed_dim],dtype=tf.float32) inputs=tf.nn.embedding_lookup(embedding,self.input_data) if self.keep_prob<1: inputs = tf.nn.dropout(inputs,self.keep_prob) out_put=[] state=self._initial_state with tf.variable_scope("LSTM_layer"): for time_step in range(num_step): if time_step>0: tf.get_variable_scope().reuse_variables() (cell_output,state)=cell(inputs[:,time_step,:],state) out_put.append(cell_output) out_put=out_put*self.mask_x[:,:,None] with tf.name_scope("mean_pooling_layer"): out_put=tf.reduce_sum(out_put,0)/(tf.reduce_sum(self.mask_x,0)[:,None]) with tf.name_scope("Softmax_layer_and_output"): softmax_w = tf.get_variable("softmax_w",[hidden_neural_size,class_num],dtype=tf.float32) softmax_b = tf.get_variable("softmax_b",[class_num],dtype=tf.float32) self.logits = tf.matmul(out_put,softmax_w)+softmax_b with tf.name_scope("loss"): self.loss = tf.nn.sparse_softmax_cross_entropy_with_logits(self.logits+1e-10,self.target) self.cost = tf.reduce_mean(self.loss) with tf.name_scope("accuracy"): self.prediction = tf.argmax(self.logits,1) correct_prediction = tf.equal(self.prediction,self.target) self.correct_num=tf.reduce_sum(tf.cast(correct_prediction,tf.float32)) self.accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32),name="accuracy") #add summary loss_summary = tf.scalar_summary("loss",self.cost) #add summary accuracy_summary=tf.scalar_summary("accuracy_summary",self.accuracy) if not is_training: return self.globle_step = tf.Variable(0,name="globle_step",trainable=False) self.lr = tf.Variable(0.0,trainable=False) tvars = tf.trainable_variables() grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, tvars), config.max_grad_norm) # Keep track of gradient values and sparsity (optional) grad_summaries = [] for g, v in zip(grads, tvars): if g is not None: grad_hist_summary = tf.histogram_summary("{}/grad/hist".format(v.name), g) sparsity_summary = tf.scalar_summary("{}/grad/sparsity".format(v.name), tf.nn.zero_fraction(g)) grad_summaries.append(grad_hist_summary) grad_summaries.append(sparsity_summary) self.grad_summaries_merged = tf.merge_summary(grad_summaries) self.summary =tf.merge_summary([loss_summary,accuracy_summary,self.grad_summaries_merged]) optimizer = tf.train.GradientDescentOptimizer(self.lr) optimizer.apply_gradients(zip(grads, tvars)) self.train_op=optimizer.apply_gradients(zip(grads, tvars)) self.new_lr = tf.placeholder(tf.float32,shape=[],name="new_learning_rate") self._lr_update = tf.assign(self.lr,self.new_lr) def assign_new_lr(self,session,lr_value): session.run(self._lr_update,feed_dict={self.new_lr:lr_value}) def assign_new_batch_size(self,session,batch_size_value): session.run(self._batch_size_update,feed_dict={self.new_batch_size:batch_size_value})

• 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
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115

• 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
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115

模型不復雜，也就不一一解釋了，在debug的時候，還是入了幾個tensorflow的坑，因此想單獨說一下這幾個坑。

坑1：tensor flow的LSTM實現?
tensorflow是已經寫好了幾個LSTM的實現類，可以很方便的使用，而且也可以選擇多種類型的LSTM，包括Basic、Bi-Directional等等。?
這個代碼用的是BasicLSTM：

#build LSTM networklstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_neural_size,forget_bias=0.0,state_is_tuple=True) if self.keep_prob<1: lstm_cell = tf.nn.rnn_cell.DropoutWrapper( lstm_cell,output_keep_prob=self.keep_prob ) cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell]*hidden_layer_num,state_is_tuple=True) self._initial_state = cell.zero_state(self.batch_size,dtype=tf.float32) out_put=[] state=self._initial_state with tf.variable_scope("LSTM_layer"): for time_step in range(num_step): if time_step>0: tf.get_variable_scope().reuse_variables() (cell_output,state)=cell(inputs[:,time_step,:],state) out_put.append(cell_output)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

在這段代碼里面，tf.nn.rnn_cell.BasicLSTMCell的初始化只需要制定LSTM神經元的隱含神經元的個數即可，然后需要初始化LSTM網絡的參數：self._initial_state = cell.zero_state(self.batch_size,dtype=tf.float32)，這句代碼乍看一下很迷糊，開始并不知道是什么意義，在實驗以及查閱源碼之后，返現這句話返回的是兩個維度是batch_size*hidden_neural_size的零向量元組，其實就是LSTM初始化的c0、h0向量，當然這里指的是對于單層的LSTM，對于多層的，返回的是多個元組。

坑2：這段代碼中的zero_state和循環代數num_step都需要制定?
這里比較蛋疼，這就意味著tensorflow中實現變長的情況是要padding的，而且需要全部一樣的長度，但是因為數據集的原因，不可能每個batch的size都是一樣的，這里就需要每次運行前，動態制定batch_size的大小，代碼中體現這個的是assign_new_batch_size函數，但是對于num_step參數卻不能動態指定（可能是因為筆者沒找到，但是指定tf.Variable()方法確實不行），出于無奈只能將數據集全部padding成指定大小的size，當然既然使用了padding那就必須使用mask矩陣進行計算。

坑3：cost返回non?
cost返回Non一般是因為在使用交叉熵時候，logits這一邊出現了0值，因此stack overflow上推薦的一般是：sparse_softmax_cross_entropy_with_logits(self.logits+1e-10,self.target)這樣寫法

訓練and結果

實驗背景：?
tensor flow: tensor flow 1.1?
platform:mac OS?
數據集：subject dataset，數據集都經過了預處理，拿到的是其在詞表中的索引?
得益于tensorboard各個參數訓練過程都可以可視化，下面是實驗訓練結果：

訓練集訓練結果：?
?
驗證集訓練結果?
?
損失函數訓練過程?
?
各個參數訓練結果：?

最終在測試集上，準確度約為85%，還不錯。

比較tensorflow和thenao

tensor flow 和 theano 是最近比較流行的深度學習框架，兩者非常相似但是兩者又不一樣，下面就我個人體驗比較下兩者的異同。

難易程度

就使用難度而言，tensorflow的便易性要遠勝于theano，畢竟theano是一堆學者研究出來的，而tensorflow是Google研究出來的，比較面向工業化。tensor flow直接集成了學術界的很多方法，比如像RNN、LSTM等都已經被tensorflow集成了，還有比如參數更新方法如梯度下降、Adadelta等也已經被tensorflow寫好了，但是對于theano這個就得自己寫，當然難易程度不一樣了。

靈活性

就靈活性而言，theano是要勝過tensor flow的，正是因為上一點theano的門檻稍高，卻也使得theano有著更大的彈性，可以實現自己任意定義的網絡結果，這里不是說tensorflow不行，tensorflow也能寫，但是使用tensorflow久了之后，寫一些自定義的結構能力就會生疏許多，比如修改LSTM內的一些結構。而Theano則沒有這個約束。

容錯性?
我個人覺得theano的容錯性是比tensor flow要高的，theano定義變量，只需要制定類型，比如imatrix、ivertor之類的而不用制定任何的維度，只要你輸入的數據和你的網絡結構圖能夠對的上的話，就沒問題，而tensorflow擇需要預先指定一些參數（如上面代碼的num_step參數），相比而言，theano的容錯能力多得多，當然這樣也有壞處，那就是可能對導致代碼調試起來比較費勁兒。

代碼?
本文的代碼可以在這里獲得，轉載請注明出處。?
25/11/2016，于北京

轉載于:https://www.cnblogs.com/DjangoBlog/p/7279988.html

總結

以上是生活随笔為你收集整理的tensorflow实现基于LSTM的文本分类方法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。