Home Php C# Sql C C++ Javascript Python Java Go Android Git Linux Asp.net Django .net Node.js Ios Xcode Cocoa Iphone Mysql Tomcat Mongodb Bash Objective-c Scala Visual-studio Apache Elasticsearch Jar Eclipse Jquery Ruby-on-rails Ruby Rubygems Android-studio Spring Lua Sqlite Emacs Ubuntu Perl Docker Swift Amazon-web-services Svn Html Ajax Xml Java-ee Maven Intellij-idea Rvm Macos Unix Css Ipad Postgresql Css3 Json Windows-server Vue.js Typescript Oracle Hibernate Internet-explorer Github Tensorflow Laravel Symfony Redis Html5 Google-app-engine Nginx Firefox Sqlalchemy Lucene Erlang Flask Vim Solr Webview Facebook Zend-framework Virtualenv Nosql Ide Twitter Safari Flutter Bundle Phonegap Centos Sphinx Actionscript Tornado Register | Login | Edit Tags | New Questions | 繁体 | 简体


5 questions online user: 5

0
votes
answers
74 views
+10

是否可以使用STATEFUL循環NN(LSTM)進行分類

1

我有一個數據集C50,000(二進制)樣本,每個樣本的128功能。類標籤也是二進制文件,即1-1。例如,樣本看起來像這樣[1,0,0,0,1,0, .... , 0,1] [-1]。我的目標是根據二進制類(即1或-1)對樣本進行分類。我想嘗試使用Recurrent LSTM來生成一個很好的分類模型。是否可以使用STATEFUL循環NN(LSTM)進行分類

tr_C, ts_C, tr_r, ts_r = train_test_split(C, r, train_size=.8) 
batch_size = 200 

print('>>> Build STATEFUL model...') 
model = Sequential() 
model.add(LSTM(128, batch_input_shape=(batch_size, C.shape[1], C.shape[2]), return_sequences=False, stateful=True)) 
model.add(Dense(1, activation='softmax')) 

print('>>> Training...') 
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 
model.fit(tr_C, tr_r, 
      batch_size=batch_size, epochs=1, shuffle=True, 
      validation_data=(ts_C, ts_r)) 

但是,我越來越壞的準確性,不超過55%:要做到這一點,我一直在使用Keras庫編寫下面的代碼。我試圖改變激活函數以及希望提高精度的損失函數,但沒有任何效果。令人驚訝的是,當我使用多層感知器時,我的準確率達到了97%左右。因此,我開始質疑LSTM是否可以用於分類,或者我的代碼有缺失或錯誤。請注意,我想知道代碼是否有缺失或錯誤來提高準確性。任何幫助或建議表示讚賞。

沙发
0
1

當你只有一個輸出單位時,你不能使用softmax作爲輸出,因爲它總會輸出一個固定值1。您需要將輸出激活更改爲sigmoid或將輸出單位編號設置爲2,並將損失設置爲categorical_crossentropy。我會建議第一個選項。

+0

感謝您的回覆。非常感激 – Kris

0
votes
answers
54 views
+10

通過tensorflow實現TFlearn imdb lstm示例

0

通過張量流實現tflearn的lstm imdb example通過tensorflow實現TFlearn imdb lstm示例

我使用了與tflearn模型相同的數據集,體系結構和超參數(嵌入大小,句子的最大長度等),但是我的模型的性能比tflearn示例差(10個曆元後,我的模型得到了精度約爲52%,而實例接近80%)。

如果您能給我一些建議以達到示例的適當性能,我會非常感激。

下面是我的代碼:

import tensorflow as tf 
from tflearn.data_utils import to_categorical, pad_sequences 
from tflearn.datasets import imdb 
from tensorflow.contrib.rnn import BasicLSTMCell 
import time 



n_class = 2 
n_words = 10000 
EMBEDDING_SIZE = 128 
HIDDEN_SIZE = 128 
MAX_LENGTH = 100 
lr = 1e-3 

epoch = 10 
TRAIN_SIZE = 22500 
validation_size = 2500 
batch_size = 128 
KP = 0.8 

# IMDB Dataset loading 
train, test, _ = imdb.load_data(path='imdb.pkl', n_words=n_words, 
           valid_portion=0.1, sort_by_len=False) 
trainX, trainY = train 
validationX, validationY = test 
testX, testY = _ 


# Data preprocessing 
# Sequence padding 
trainX = pad_sequences(trainX, maxlen=MAX_LENGTH, value=0.) 
validationX = pad_sequences(validationX, maxlen=MAX_LENGTH, value=0.) 
testX = pad_sequences(testX, maxlen=MAX_LENGTH, value=0.) 

# Converting labels to binary vectors 
trainY = to_categorical(trainY, n_class) 
validationY = to_categorical(validationY, n_class) 
testY = to_categorical(testY, n_class) 

graph = tf.Graph() 
with graph.as_default(): 
    # input 
    text = tf.placeholder(tf.int32, [None, MAX_LENGTH]) 
    labels = tf.placeholder(tf.float32, [None, n_class]) 
    keep_prob = tf.placeholder(tf.float32) 

    embeddings_var = tf.Variable(tf.truncated_normal([n_words, EMBEDDING_SIZE]), trainable=True) 
    text_embedded = tf.nn.embedding_lookup(embeddings_var, text) 

    print(text_embedded.shape) # [batch_size, length, embedding_size] 
    word_list = tf.unstack(text_embedded, axis=1) 

    cell = BasicLSTMCell(HIDDEN_SIZE) 
    dropout_cell = tf.contrib.rnn.DropoutWrapper(cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob) 
    outputs, encoding = tf.nn.static_rnn(dropout_cell, word_list, dtype=tf.float32) 

    logits = tf.layers.dense(outputs[-1], n_class, activation=None) 

    loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=labels)) 
    optimizer = tf.train.AdamOptimizer(lr).minimize(loss) 

    prediction = tf.argmax(logits, 1) 
    accuracy = tf.reduce_mean(tf.cast(tf.equal(prediction, tf.argmax(labels, 1)), tf.float32)) 


train_steps = epoch * TRAIN_SIZE // batch_size + 1 
print("Train steps: ", train_steps) 


with tf.Session(graph=graph) as sess: 
    tf.global_variables_initializer().run() 
    print("Initialized!") 
    s = time.time() 
    offset = 0 

    for step in range(train_steps): 
     offset = (offset * step) % (TRAIN_SIZE - batch_size) 
     batch_text = trainX[offset: offset + batch_size, :] 
     batch_label = trainY[offset: offset + batch_size, :] 
     fd = {text: batch_text, labels: batch_label, keep_prob: KP} 
     _, l, acc = sess.run([optimizer, loss, accuracy], feed_dict=fd) 

     if step % 100 == 0: 
      print("Step: %d loss: %f accuracy: %f" % (step, l, acc)) 

     if step % 500 == 0: 
      v_l, v_acc = sess.run([loss, accuracy], feed_dict={ 
       text: validationX, 
       labels: validationY, 
       keep_prob: 1.0 
      }) 
      print("------------------------------------------------") 
      print("Validation: step: %d loss: %f accuracy: %f" % (step, v_l, v_acc)) 
      print("------------------------------------------------") 
    print("Training finished, time consumed:", time.time() - s, " s") 
    print("Test accuracy: %f" % accuracy.eval(feed_dict={ 
     text: testX, 
     labels: testY, 
     keep_prob: 1.0 
    })) 
沙发
0
0

對不起,我犯了一個愚蠢的錯誤! 損失:

損耗= tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = logits,標籤=標籤))

應該是

損耗= TF .reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = logits,labels = labels))

那麼,準確性就像tflearn示例

0
votes
answers
58 views
+10

經常性神經網絡:參數共享點是什麼?無論如何,填充不會訣竅?

1

剛開始研究RNN和LSTM ...有一個問題沒有回答我看過的任何資源:經常性神經網絡:參數共享點是什麼?無論如何,填充不會訣竅?

以下是我如何理解RNN中參數共享的要點。我的問題是:

  1. 我對RNN的理解,總結如下,是否正確?
  2. 在Keras的實際代碼示例中,我研究了LSTM,它們將句子填充到相同的長度。通過這樣做,這不會沖走RNN中參數共享的全部目的嗎?

在常規的前饋神經網絡中,每個輸入單元都被分配一個單獨的參數,這意味着輸入單元(特徵)的數量對應於要學習的參數的數量。在處理例如圖像數據,輸入單元的數量在所有訓練樣例中都相同(通常是恆定像素大小*像素大小* rgb幀)。

但是,像句子一樣的順序輸入數據可能會有很大的變化長度,這意味着根據處理哪個例句,參數的數量將不會相同。這就是爲什麼參數共享對於有效處理順序數據是必需的:它確保模型始終具有相同的輸入大小,而不管序列長度如何,因爲它是根據從一個狀態到另一個狀態的轉換來指定的。因此可以在每個時間步使用具有相同權重的相同轉換函數(輸入到隱藏權重,隱藏輸出權重,隱藏到隱藏權重)。最大的優點是它允許通用化來排序沒有出現在訓練集中的長度。

非常感謝。

+0

參見https://stats.stackexchange.com/q/221513/130598 – Maxim

+0

謝謝,很好的提示! –

沙发
0
0

參數共享

能夠有效地處理不同長度的序列並不是參數共享的唯一優勢。正如你所說,你可以通過填充實現。參數共享的主要目的是減少模型必須學習的參數。這是使用RNN的全部目的。

如果您要爲每個時間步學習不同的網絡,並將第一個模型的輸出提供給第二個模型等,您最終將得到一個常規的前饋網絡。對於20個時間步驟,您需要學習20個模型。在卷積網絡中,參數由卷積濾波器共享,因爲當我們可以假設在圖片的不同區域存在相似的有趣圖案時(例如簡單的邊緣)。這大大減少了我們必須學習的參數數量。類似地,在序列學習中,我們經常可以假設在不同的時間步驟有相似的模式。比較'Yesterday I ate an apple''I ate an apple yesterday'。這兩句話意思相同,但部分發生在不同的時間步驟。通過共享參數,您只需要瞭解該部分的含義。否則,您必須在每個時間步驟學習它,它可能發生在您的模型中。

共享參數有一個缺點。因爲我們的模型在每個時間步驟對輸入應用相同的轉換,所以現在必須學習一個對所有時間步驟都有意義的轉換。所以,必須記住,哪個單詞出現在哪個時間步,即'chocolate milk'不應該導致與'milk chocolate'相同的隱藏和存儲狀態。但與使用大型前饋網絡相比,這個缺點很小。

填充

作爲填充序列:主要目的是不直接讓模型預測不同長度的序列。就像你說的那樣,這可以通過使用參數共享來完成。填充用於有效的訓練 - 特別是在訓練時保持低的計算圖。沒有填充,我們有兩種訓練選項:

  1. 我們展開每個訓練樣本的模型。因此,當我們有一個長度爲7的序列時,我們將模型展開爲7個時間步長,饋送序列,通過7個時間步長進行反向傳播並更新參數。理論上這看起來很直觀。但實際上,這是非常低效的。當使用TensorFlow時,您會在每個訓練步驟創建一個新的計算圖,因爲TensorFlows計算圖不允許重複性,它們是前饋的。
  2. 另一種選擇是在開始訓練前創建計算圖。我們讓他們分享相同的權重,併爲我們的訓練數據中的每個序列長度創建一個計算圖。但是當我們的數據集有30個不同的序列長度時,這意味着在訓練期間有30個不同的圖形,所以對於大型模型,這是不可行的。

這就是爲什麼我們需要填充。我們將所有序列填充到相同長度,然後只需在開始訓練之前構造一個計算圖。如果序列長度非常短且很長(例如5和100),則可以使用bucketing and padding。這意味着,您將序列填充到不同的桶長度,例如[5,20,50,100]。然後,爲每個存儲桶創建一個計算圖。這樣做的好處是,你不必填充長度爲5到100的序列,因爲你會浪費大量時間在那裏「學習」95個填充令牌。

+1

非常感謝!這是一個非常有用的答案! –

0
votes
answers
73 views
+10

Keras爲什麼不能概括我的數據?

0

我一直在嘗試實現一個基本的多層LSTM迴歸網絡來找出加密電子貨幣價格之間的相關性。Keras爲什麼不能概括我的數據?

在遇到無法使用的訓練結果後,我決定嘗試使用一些沙盒代碼,以確保在重試完整數據集之前我已經明白了。

問題是我不能讓凱拉斯推廣我的數據。

ts = 3 
in_dim = 1 

data = [i*100 for i in range(10)] 

# tried this, didn't accomplish anything 
# data = [(d - np.mean(data))/np.std(data) for d in data] 

x = data[:len(data) - 4] 
y = data[3:len(data) - 1] 

assert(len(x) == len(y)) 

x = [[_x] for _x in x] 
y = [[_y] for _y in y] 

x = [x[idx:idx + ts] for idx in range(0, len(x), ts)] 
y = [y[idx:idx + ts] for idx in range(0, len(y), ts)] 

x = np.asarray(x) 
y = np.asarray(y) 

X看起來是這樣的:

[[[ 0] 
    [100] 
    [200]] 

[[300] 
    [400] 
    [500]]] 

和y:

[[[300] 
    [400] 
    [500]] 

[[600] 
    [700] 
    [800]]] 

這個效果很好,當我預測使用非常相似的數據集,但不會推廣的時候我嘗試使用縮放值類似的順序

model = Sequential() 

model.add(BatchNormalization(
    axis = 1, 
    input_shape = (ts, in_dim))) 

model.add(LSTM(
    100, 
    input_shape = (ts, in_dim), 
    return_sequences = True)) 

model.add(TimeDistributed(Dense(in_dim))) 
model.add(Activation('linear')) 
model.compile(loss = 'mse', optimizer = 'rmsprop') 

model.fit(x, y, epochs = 2000, verbose = 0) 

p = np.asarray([[[10],[20],[30]]]) 
prediction = model.predict(p) 
print(prediction) 

打印

[[[ 165.78544617] 
    [ 209.34489441] 
    [ 216.02174377]]] 

我想

[[[ 40.0000] 
    [ 50.0000] 
    [ 60.0000]]] 

我怎麼能格式化這個所以,當我在一個序列插頭是一個完全不同的刻度值,網絡仍然會輸出它的預測值?我試着對訓練數據進行規範化處理,但結果仍然完全無法使用。

我在這裏做了什麼錯?

+0

我還發現這個關於使用LSTM對單變量數據進行自迴歸的討論很有用:https://machinelearningmastery.com/suitability-long-short-term-memory-networks - 時間序列預測/ - 不能說它完全回答了我的問題,但它提供了一些有關LSTM如何不能達到時間序列預測預期的見解。 – Phil

+0

你高估了深度學習的力量。你只給它乘以100作爲輸入,並期望它也推廣到10的倍數。因爲10不是特殊數字,所以這種轉換學習也應該適用於任何數字的整數倍數。但是,您的模型應該如何知道這是它應該完成的任務?你的訓練數據決不會告訴你。任務也可以是在當前時間步驟簡單地將100添加到輸入。爲了能夠推廣,您需要提供包含泛化示例的模型訓練數據。 –

沙发
0
0

如何在發送到您的LSTM之前轉換您的輸入數據,使用類似sklearn.preprocessing.StandardScaler?經過預測,你可以打電話給scaler.inverse_transform(預測)

34
votes
answers
51 views
+10

Tensorflow LSTM中的c_state和m_state是什麼?

Tens.nn.rnn_cell.LSTMCell的Tensorflow r0.12文檔將其描述為init:

  tf.nn.rnn_cell.LSTMCell .__ call __(inputs,state,scope = None)   

其中 state 如下:

state:如果state_is_tuple為False,則必須是狀態Tensor,2- D,批處理x state_size。如果state_is_tuple為True,則它必須是狀態Tensors的元組,兩者都是2-D,列大小為c_state和m_state。

aare c_state m_state 以及它們如何適用於LSTM?我無法在文檔中的任何位置找到對它們的引用。

up vote 14 down vote accepted favorite
沙发
+140
+50

我偶然發現了同樣的問題,這是我理解的方式!簡約LSTM示例:

 導入tensorflow為tf sample_input = tf.constant([[1,2,3]],dtype = tf.float32)LSTM_CELL_SIZE = 2 lstm_cell = tf.nn.rnn_cell .BasicLSTMCell(LSTM_CELL_SIZE,state_is_tuple = True)state =(tf.zeros([1,LSTM_CELL_SIZE]),)* 2輸出,state_new = lstm_cell(sample_input,state)init_op = tf.global_variables_initializer()sess = tf.Session() sess.run(init_op)print sess.run(輸出)  

注意 state_is_tuple = True 所以將 state 傳遞給this < code> cell ,它需要是 tuple 形式。 c_state m_state 可能是“ LSTM_CELL_SIZE * 2])輸出,state_new = lstm_cell(sample_input,state)

NEW WAY:

  lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(LSTM_CELL_SIZE ,state_is_tuple = True)state =(tf.zeros([1,LSTM_CELL_SIZE]),)* 2輸出,state_new = lstm_cell(sample_input,state)  

所以,基本上我們所做的一切,將 state 從1個長度 4 更改為兩個長度 2 的張量。內容保持不變。 [0,0,0,0] 變為([0,0],[0,0])(這應該會讓它更快) rnn_cell.BasicLSTMCell(LSTM_CELL_SIZE,state_is_tuple = True)state =(tf.zeros([1,LSTM_CELL_SIZE]),)* 2輸出,state_new = lstm_cell(sample_input,state)

所以,基本上我們所做的就是將 state 從長度 4 的1個張量改為長度 2 的兩個張量。內容保持不變。 [0,0,0,0] 變為([0,0],[0,0])(這應該會讓它更快) rnn_cell.BasicLSTMCell(LSTM_CELL_SIZE,state_is_tuple = True)state =(tf.zeros([1,LSTM_CELL_SIZE]),)* 2輸出,state_new = lstm_cell(sample_input,state)

所以,基本上我們所做的就是將 state 從長度 4 的1個張量改為長度 2 的兩個張量。內容保持不變。 [0,0,0,0] 變為([0,0],[0,0])(這應該會讓它更快) 分為兩個長度 2 的張量。內容保持不變。 [0,0,0,0] 變為([0,0],[0,0])(這應該會讓它更快) 分為兩個長度 2 的張量。內容保持不變。 [0,0,0,0] 變為([0,0],[0,0])(這應該會讓它更快)

+180

我同意文件不清楚。查看 tf.nn.rnn_cell.LSTMCell .__ call __ 澄清(我從TensorFlow 1.0.0獲取代碼):

  def __call __(self,inputs,state,scope =無):“”“運行LSTM的一步.Args:輸入:輸入Tensor,2D,批處理x num_units。狀態:如果`state_is_tuple`為False,則必須是狀態Tensor,`2-D,batch x state_size `。如果`state_is_tuple`為True,那麼它必須是狀態Tensors的元組,都是'2-D`,列大小為`c_state`和`m_state`。範圍:VariableScope用於創建的子圖; 默認為“lstm_cell”。返回:包含以下內容的元組: - 一個`2-D,[batch x output_dim]`,Tensor表示在前一個狀態為`state`時讀取`inputs`後LSTM的輸出。如果設置了num_proj,則output_dim為:num_proj,否則為num_units。 - 當前一個狀態為“狀態”時,讀取“輸入”後表示LSTM新狀態的張量。與`state`相同的類型和形狀。引發:ValueError:如果無法通過靜態形狀推斷從輸入推斷輸入大小。“”num_proj = self._num_units如果self._num_proj為None否則self._num_proj如果self._state_is_tuple:(c_prev,m_prev)= state else:c_prev = array_ops.slice(state,[0,0],[ -  1,自。
     
			
        

如有疑問,請務必瀏覽原始紙張。將代碼鏈接到DL數學是非常令人滿意的 - vega於2017年9月1日21:34

+20

也許這段代碼的摘錄會有所幫助

  def __call __(self,inputs,state,scope = None):“”“長短期記憶細胞(LSTM)。” “with vsvariable_scope(範圍或類型(self).__ name__):#”BasicLSTMCell“#門的參數被連接成一個乘法以提高效率。if self._state_is_tuple:c,h = state else:c,h = array_ops.split(1,2,state)concat = _linear([inputs,h],4 * self._num_units,True)#i = input_gate,j = new_input,f = forget_gate,o = output_gate i,j,f,o = array_ops.split(1,4,concat)new_c =(c * sigmoid(f + self._forget_bias)+ sigmoid(i)* self._activation (j))new_h = self._activation(new_c)* sigmoid(o)if self._state_is_tuple:
     
			
        

我真的很有幫助。因此,對於每個LSTMCell,__ call __()函數的輸出如下:new_h,LSTMStateTuple(new_c,new_h)。其中new_c是實際狀態(意味著上下文) - Ziemo 18年10月30日16:13

0

https://github.com /tensorflow/tensorflow/blob/r1.2/tensorflow/python/ops/rnn_cell_impl.py

第308 - 314行

類LSTMStateTuple(_LSTMStateTuple):“ “”LSTM Cells用於 state_size zero_state 和輸出狀態的元組。按順序存儲兩個元素:(c,h) 。僅在 state_is_tuple = True 。“”“時使用

m_state與h_state具有相同的含義。 - Z Chen 17年7月21日在8:54