Verständnis Tensorflow LSTM-Input-Form

Ich habe einen Datensatz X besteht N = 4000 samples, jede Probe besteht aus d = 2 Funktionen (kontinuierliche Werte) spanning zurück t = 10 Zeitschritte. Ich habe auch das entsprechende 'Label' der einzelnen Probe, die sind auch kontinuierliche Werte, bei Schritt 11.

In dem moment, in dem mein Datensatz ist in der Form X: [4000,20], Y: [4000].

Will ich Zug eine LSTM mit TensorFlow, um vorherzusagen, den Wert von Y (regression), da die 10 vorherigen Eingänge der d-Funktionen, aber ich bin eine harte Zeit der Umsetzung dieser in TensorFlow.

Das Hauptproblem was ich im moment haben, ist das Verständnis, wie TensorFlow erwartet bei der Eingabe formatiert werden. Ich habe gesehen, verschiedene Beispiele, wie diese, aber diese Beispiele beschäftigen sich mit einer großen Schnur von kontinuierlichen Zeitreihen-Daten. Meine Daten werden verschiedene Proben, die jeweils eine unabhängige Zeitreihen.

Hallo, ich versuche etwas umzusetzen, sehr ähnlich zu dem, was Sie getan haben und hoffe Sie können mir ein paar Tipps geben, da tensorflow ist immer noch umwerfend für mich. Für die Installation ist, wie sieht der input-Datei eigentlich Aussehen? Ist jedes sample im Grunde eine Liste der Länge 10, der mit jedem element mit 2 Funktionen und für jede Probe, die Sie ein label haben? z.B. [[f1,f2], [f1,f2], ...]

InformationsquelleAutor Renier Botha | 2016-09-05

11

Den Dokumentation von tf.nn.dynamic_rnn Staaten:

inputs: Die RNN-inputs. Wenn time_major == False (Standard), muss dieser ein Tensor der Form: [batch_size, max_time, ...] oder verschachtelte Tupel dieser Elemente.

In Ihrem Fall bedeutet dies, dass der input sollte eine Form [batch_size, 10, 2]. Statt training auf alle 4000 Sequenzen auf einmal, die Sie verwenden würden, nur batch_size viele von Ihnen in jedem training iteration. Etwas wie das folgende sollte funktionieren (Hinzugefügt Umformen, für die Klarheit):
```
batch_size = 32
# batch_size sequences of length 10 with 2 values for each timestep
input = get_batch(X, batch_size).reshape([batch_size, 10, 2])
# Create LSTM cell with state size 256. Could also use GRUCell, ...
# Note: state_is_tuple=False is deprecated;
# the option might be completely removed in the future
cell = tf.nn.rnn_cell.LSTMCell(256, state_is_tuple=True)
outputs, state = tf.nn.dynamic_rnn(cell,
                                   input,
                                   sequence_length=[10]*batch_size,
                                   dtype=tf.float32)
```
Aus der Dokumentation, outputs werden der Form [batch_size, 10, 256], d.h. einer 256-Ausgabe für jeden Zeitschritt. state wird ein Tupel Formen [batch_size, 256]. Sie konnte Vorhersagen, Ihre endgültige Wert, einer für jede Sequenz von:
```
predictions = tf.contrib.layers.fully_connected(state.h,
                                                num_outputs=1,
                                                activation_fn=None)
loss = get_loss(get_batch(Y).reshape([batch_size, 1]), predictions)
```
Die Zahl 256 in den Formen von outputs und state ist bestimmt durch cell.output_size resp. cell.state_size. Bei der Erstellung der LSTMCell wie oben, das sind die gleichen. Siehe auch die LSTMCell Dokumentation.
- Danke für die Antwort! Ich werde versuchen, diese bald aus, und Sie wissen lassen, wenn es löst mein problem. Eine Frage aber: was genau macht die 256 finden Sie in tf.nn.rnn_cell.LSTMCell(256, state_is_tuple=True)? Ich habe die Dokumentation gelesen, und der Wert wird bezeichnet als n_units. Bedeutet das, dass die Anzahl der Zeitschritte? D. H. der Speicher von der LSTM-Zelle? Sorry, ich weiß, dies ist eine Erweiterung der ursprünglichen Frage.
- Die Anzahl der Zeit, die Schritte in jeder Sequenz ist gegeben durch die sequence_length parameter, die Sie geben, in tf.nn.dynamic_rnn. Die 256 bezieht sich auf die Größe des internen Zustand des LSTM, die aktualisiert wird jedes mal, wenn Schritt.
- Frage: würden Sie nicht wollen, dass Ihr vollständig vernetzten Schicht für Vorhersagen haben num_outputs=batch_size? Dann müsste man eine Prognose am Ende der jeweiligen Zeitreihe in deiner batch?
- Die vollständig vernetzten Schicht hat die Ausgabe die Form [batch_size, num_outputs], d.h. num_outputs ist die Anzahl der Ausgänge für jeden Eintrag in der batch.
InformationsquelleAutor fwalch

(Diese Antwort "Adressen" das problem bei der direkten np.reshape() nicht organisieren das Finale-array, wie wir es wollen. Wenn wir wollen direkt Umformen in 3D-np.Umformen wird es tun, aber passen Sie heraus für die Letzte Organisation, der Eingang).

In meinen persönlichen versuchen endlich dieses problem beheben füttern Eingabe-Form für RNN und verwechseln nicht mehr, ich gebe meine "persönliche" Erklärung dafür.

In meinem Fall (und ich denke, dass viele andere haben diese Organisation Schema in Ihre feature-Matrizen), die meisten der blogs, die draußen "nicht helfen". Lass es auf einen Versuch in so konvertieren Sie 2D-feature-matrix in ein 3D geformt für eine RNNs.

Sagen wir, wir haben diese Organisation in unserer feature-matrix: wir haben 5 Beobachtungen (d.h. Zeilen - für convention, die ich denke, es ist die logische Begriff zu verwenden) und in jede Zeile, wir haben 2 bietet für JEDEN Zeitschritt (und wir haben 2 Zeitintervallen), wie diese:

(Die df um besser zu verstehen, visuell meine Worte)

In [1]: import numpy as np                                                           

In [2]: arr = np.random.randint(0,10,20).reshape((5,4))                              

In [3]: arr                                                                          
Out[3]: 
array([[3, 7, 4, 4],
       [7, 0, 6, 0],
       [2, 0, 2, 4],
       [3, 9, 3, 4],
       [1, 2, 3, 0]])

In [4]: import pandas as pd                                                          

In [5]: df = pd.DataFrame(arr, columns=['f1_t1', 'f2_t1', 'f1_t2', 'f2_t2'])         

In [6]: df                                                                           
Out[6]: 
   f1_t1  f2_t1  f1_t2  f2_t2
0      3      7      4      4
1      7      0      6      0
2      2      0      2      4
3      3      9      3      4
4      1      2      3      0

Wir werden nun die Werte, mit Ihnen zu arbeiten. Die Sache hier ist, dass RNNs übernehmen "Zeitschritt" dimension, um Ihre Eingabe, wegen Ihrer architechtural Natur. Wir können uns vorstellen, dass die dimension als stapeln von 2D-arrays, die eine hinter der anderen, für die Anzahl von Zeitintervallen, die wir haben. In diesem Fall haben wir zwei Zeitintervallen; so haben wir zwei 2D-arrays gestapelt: eine für timestep1 und dahinter, die man für timestep2.

In der Realität, in der 3D-Eingabe, die wir brauchen, um machen, wir haben noch 5 Beobachtungen. Die Sache ist, dass wir brauchen, um Sie zu arrangieren anders: die RNN wird die erste Zeile (oder der angegebenen batch - aber wir werden es einfach halten hier) des ersten Arrays (d.h. timestep1) und die erste Zeile des zweiten gestapelten array (d.h. timestep2). Dann die zweite Zeile...bis der Letzte (der 5. in unserem Beispiel). So, in jeder Zeile eines jeden Zeitschritt, müssen wir die zwei Besonderheiten, die natürlich getrennt in verschiedenen arrays jeder entsprechend seiner Zeitschritt. Mal sehen, das mit den zahlen.

Werde ich zwei arrays zum besseren Verständnis. Denken Sie daran, dass aufgrund unserer organisatorischen Regelung im df, Sie haben vielleicht bemerkt, dass wir brauchen, um die ersten zwei Spalten (D. H. die Merkmale 1 und 2 für die timestep1) als ERSTEN ARRAY DES STACKS und die letzten beiden Spalten, d.h. die 3. und die 4., wie unser ZWEITES ARRAY auf DEM STACK, so dass alles, was Sinn macht, schließlich.

In [7]: arrStack1 = arr[:,0:2]                                                       

In [8]: arrStack1                                                                    
Out[8]: 
array([[3, 7],
       [7, 0],
       [2, 0],
       [3, 9],
       [1, 2]])

In [9]: arrStack2 = arr[:,2:4]                                                       

In [10]: arrStack2                                                                   
Out[10]: 
array([[4, 4],
       [6, 0],
       [2, 4],
       [3, 4],
       [3, 0]])

Schließlich das einzige, was wir tun müssen, ist die Stapel beiden arrays ("eine hinter der anderen"), als wären Sie Teil derselben endgültige Struktur:

In [11]: arrfinal3D = np.stack([arrStack1, arrStack2])                               

In [12]: arrfinal3D                                                                  
Out[12]: 
array([[[3, 7],
        [7, 0],
        [2, 0],
        [3, 9],
        [1, 2]],

       [[4, 4],
        [6, 0],
        [2, 4],
        [3, 4],
        [3, 0]]])

In [13]: arrfinal3D.shape                                                            
Out[13]: (2, 5, 2)

Das ist es: wir haben unsere feature-matrix bereit zur Einspeisung in das RNN-Zelle, unter Berücksichtigung unserer Organisation der 2D-feature-matrix.

(Für ein one-liner in Bezug auf alle diese, die Sie verwenden könnten:

In [14]: arrfinal3D_1 = np.stack([arr[:,0:2], arr[:,2:4]])                           

In [15]: arrfinal3D_1                                                                
Out[15]: 
array([[[3, 7],
        [7, 0],
        [2, 0],
        [3, 9],
        [1, 2]],

       [[4, 4],
        [6, 0],
        [2, 4],
        [3, 4],
        [3, 0]]])

¡Hoffe, das hilft!

InformationsquelleAutor Ezarate11

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.