[PYTHON] Da ich Tensorflow 2 Monate lang berührt habe, habe ich das Faltungs-Neuronale Netzwerk auf leicht verständliche Weise mit 95,04% der "handgeschriebenen Hiragana" -Identifikation erklärt.

Anscheinend habe ich einen Tag gebraucht, um den Artikel zu schreiben, nachdem ich 5 Stunden lang mit dem Datensatz fertig gegen die Binärdatei gekämpft hatte. Es ist schwer, einen Artikel sorgfältig zu schreiben. Ufufu ☆

Letztes Mal: Ich bin weder Programmierer noch Datenwissenschaftler, aber ich habe Tensorflow einen Monat lang berührt, daher ist es sehr einfach zu verstehen Danach dachte ich, ich würde die Expertenausgabe von MNIST erklären, aber da es eine große Sache war, war es keine Zahl, sondern ** ein Hiragana-Datensatz **, während insgesamt 71 Zeichen identifiziert wurden ** eine Erklärung des "Faltungs-Neuronalen Netzwerks" ** Ich will. Da es sich in englischer Sprache um ein Convolutional Neural Network handelt, wird es im Folgenden als ** CNN ** bezeichnet.

Der Code stammt größtenteils von Tensorflows Tutorial-Experten, daher frage ich mich, ob er nach dem Betrachten leichter zu verstehen ist.

1: Datensatz

Ich habe es von der ETL Handwritten Character Database erhalten, die von AIST veröffentlicht wurde. (Ehemals: ETL (Electro Technical Laboratory) für Densoken) Wenn Sie es wagen, es zu benennen, handelt es sich nicht um einen MNIST ** MAIST ** -Datensatz (Mixed Advanced Industrial Science and Technology)

Die tatsächlichen Daten sind 127 x 128, was sehr groß ist. Sie wurden jedoch auf 28 x 28 reduziert, um dem Tensorflow-Lernprogramm zu entsprechen.

2: Was wichtig ist, sind die Funktionen und wie man die Abmessungen reduziert!

Nun, dies ist ein Experten-Tutorial. Auch wenn Sie plötzlich ein neues Wort wie Folding oder Pooling sagen, ist es nicht wirklich Chimpunkampun?

Reden wir noch ein bisschen, um uns mit dem letzten Mal zu verbinden, oder? Richtig?

Im Anfänger-Tutorial wurde das Gewicht "W: [784, 10]" in einer Matrix berechnet, um das Bild auf 10 Dimensionen zu reduzieren und die Antworten abzugleichen. Dieses Gewicht ist in Pixeleinheiten angegeben. Es ist derjenige, der sagt: "Die Möglichkeit von 0 beträgt hier 0,3%, die Möglichkeit von 1 beträgt 21,1% ... Honyahonya."

Wenn Sie jedoch eine winzige 0 ** sehen, die ** 0 ist, aber weit darunter liegt, besteht eine gute Chance, dass das mit diesem Gewicht verkleinerte Bild "Die Antwort ist 6!" Zumindest die Wahrscheinlichkeit, eine "0" -Antwort zu erhalten, ist erheblich verringert. Dies liegt daran, dass die Auswertung des Pixels um die Mitte des Gewichts "W" "0 Möglichkeit ist" -0,23017341 "ist. Wenn Sie ein Mensch sind, können Sie sofort beurteilen, dass es "0 ist, weil es rund ist". Dieses ** "weil es rund ist" ** ist eigentlich ein ** wichtiges Merkmal **.

Um etwas näher darauf einzugehen, sollte es eine Beziehung zwischen dem Zielpixel und den umgebenden Pixeln geben, da es sich um ein Bild handelt. Wenn jedoch der Vektor transformiert und die Dimension reduziert wird, kann diese Beziehung (Merkmal) verloren gehen. Wenn ich auf den Vektorgraphen zurückblicke, der das letzte Mal das Bild von "1" war, kann ich die Beziehung zu den umgebenden Pixeln von hier aus überhaupt nicht verstehen.

Das Reduzieren dieses 784-dimensionalen Vektors auf einen 10-dimensionalen Vektor ist eine ziemlich grobe Antwort.

Mit anderen Worten kann gesagt werden, dass das ** Merkmal von ** "rund" ** bei der Dimensionsreduzierung ** verloren gegangen ist.

Handgeschriebenes Hiragana kann mit dem Modell des Anfänger-Tutorials nicht erkannt werden.

Im Tensorflow-Tutorial liegt die korrekte Antwortrate zwischen 91% für Anfänger und 99,2% für Experten, sodass sie für die durchschnittliche Person "Hmm" ergibt. (Tatsächlich scheint es den Leuten auf dem Gebiet der Wissenschaft offensichtlich zu sein, dass dieser Unterschied sehr groß ist. Es wurde auch in Breaking Bad gesagt.)

Diesmal war Hiragana MAIST ein sehr guter Maßstab für den Vergleich der beiden Tutorials.

MAIST-beginner.py

train_step = tf.train.GradientDescentOptimizer(1e-4).minimize(cross_entropy)
#Wenn die Anzahl der Lernvorgänge groß ist, wird sie abweichen. Setzen Sie die Lernrate daher auf 1e.-Wechseln Sie zu 4

for i in range(10000):                                                                                 
  batch = random_index(50) #load 50 examples                                                           
  train_step.run(feed_dict={x: train_image[batch], y_: train_label[batch]})                            
                                                                  
print accuracy.eval(feed_dict={x: test_image, y_: test_label})   

> simple_maist  10000 steps accuracy 0.287933  
> simple_maist  50000 steps accuracy 0.408602
> simple_maist 100000 steps accuracy 0.456392

Was meinst du damit ... Mit dem Code aus dem Anfänger-Tutorial, den ich das letzte Mal verwendet habe, waren es nur ** 28,79% **, auch wenn ich 10.000 Mal trainiert habe. 40,86%, selbst wenn sie 50.000 Mal trainiert wurden, 45,63%, selbst wenn sie 100.000 Mal trainiert wurden.

Sie können sehen, wie beängstigend es ist, Features aufgrund von Dimensionsreduzierungen zu verlieren.

Die klugen Leute müssen das gedacht haben. "Um zu antworten, ist eine Dimensionsreduzierung erforderlich, aber ich möchte die Funktionen beibehalten."

Also das Expertenmodell: ** CNN ** ** Merkmalserkennung ** Faltung: Faltung ** Funktionserweiterung ** Aktivierung: Aktivierung ** Dimensionsreduzierung ** Pooling: Pooling ** Vollständig verbunden ** Verbundene Ebene (ausgeblendet): Ausgeblendete Ebene Wird auftauchen.

3: Faltung: Faltung

Schauen wir uns nun den Inhalt der Reihe nach an. Zunächst die Erklärung des Codes

Funktionserkennung.py

 x_image = tf.reshape(x, [-1,28,28,1])

def weight_variable(shape):                        
  initial = tf.truncated_normal(shape, stddev=0.1) 
  return tf.Variable(initial)  

def conv2d(x, W):                                                 
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

W_conv1 = weight_variable([5, 5, 1, 32])
Conv1 = conv2d(x_image, W_conv1)
                   

CNN verarbeitet das Bild nicht als Vektor, sondern mit einer 28x28-Matrix, die die Bedeutung der Merkmale als Bild beibehält. In Bezug auf Tensorflow gibt "x_image = tf.reshape (x, [-1,28,28,1])" einen Vektor an die "Form" des Originalbilds zurück.

Und die Faltung der Merkmalserkennung. Das Wort "Falte" macht keinen Sinn, und ich habe es ein letztes Mal geschrieben, aber es ist auch eine "Gewichts" -Variable, also interpretieren wir es als Filter. Die Variable Variable / Tensor[5, 5, 1, 32]von Rang 4 ist in W_conv1 enthalten. Dieser Tensor "W_conv1:" ist "Form", aber die Bedeutung ist "[Breite, Höhe, Eingabe, Filter]", und auf jedes Bild werden Filter der Größe 5x5 angewendet.

Das letzte Mal war die Initialisierung "tf.zeros ()", aber dieses Mal ist die Initialisierung "tf.truncated_normal ()" und eine Zufallszahl wird eingegeben.

Da es sich um einen Filter handelt, visualisieren wir ihn tatsächlich. Ja, nicht!

Nun, ich weiß es nicht! Diese Filter werden natürlich mit "conv2d (x_image, W_conv1)" auf das Bild angewendet. Angewandtes Bild: Klicken Sie hier. Ja, nicht!

Es wird schwieriger zu verstehen. Dies sollte der Fall sein, da diese Filter überhaupt nicht optimiert wurden.

Schauen wir uns den Filter und das angewendete Bild an, nachdem das Lernen abgeschlossen ist. Filter nach dem Lernen: Ich habe nicht das Gefühl, dass es linienartig ist.

Anwendbares Bild nach Abschluss des Lernens: (Zu): Irgendwie ist der dreidimensionale Effekt fantastisch! Ich habe das Gefühl, es hat zugenommen

Es ist ein wenig schwierig für Menschen zu interpretieren ...

4: Aktivierung: Aktivierung

Einige Funktionen sind aussagekräftig, während andere leere weiße Pixel sind, die bedeutungslos sind. Ich möchte nur die Merkmale so weit wie möglich hervorheben, bevor ich die Abmessungen reduziere. Hier kommt die Aktivierungsfunktion Relu ins Spiel. (Bias ist nicht mehr (^ o ^) Standard ...)

Aktivierung.py

def bias_variable(shape):                       
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)

b_conv1 = bias_variable([32])   
h_conv1 = tf.nn.relu(Conv + b_conv1)

Die Vorspannung "b_conv1" ist ein Tensor, der mit der durch "tf.constant ()" angegebenen Zahl gefüllt ist. Diesmal ist es "0.1".

Die Aktivierung ist auch leicht zu verstehen, übergeben Sie einfach die vorherige "Conv" an "tf.nn.relu".

• Ergänzung 2016/5/16 Obwohl es sich um eine Relu-Funktion handelt, da es sich um eine gleichgerichtete lineare Einheit handelt, wird einfach ausgedrückt, was Sie in der ** korrigierten linearen Funktion ** haben, übergeben. Im Fall von Relu wird der Eingang, wenn er "0" oder weniger ist, dh wenn es sich um eine negative Zahl handelt, auf "0" korrigiert. Sie können es auf einen Blick verstehen, indem Sie sich die Abbildung ansehen. Es ist so. Eigentlich gibt es andere wie elu und Leaky Relu. Es ist keine gerade Linie, und es gibt auch Sigmoid- und Tanh-Funktionen.

In Bezug auf MAIST ist der numerische Wert diesmal im dunklen Teil des Bildes niedrig und wird vom Computer nicht als Merkmal erkannt, sodass er sich in einem Zustand (numerischer Wert) befindet, den ich nicht zu sehr berücksichtigen möchte. Daher werden alle unnötigen Personen durch die Aktivierungsfunktion zu "0" gemacht. Kurz gesagt, es ist ein Cut-Off. Ich habe Angst vor Umstrukturierungen.

Die Aktivierung ist so.py

-> x
[  1.43326855 -10.14613152   2.10967159   6.07900429  -3.25419664  
-1.93730605  -8.57098293  10.21759605   1.16319525   2.90590048]

-> Relu(x)
[  1.43326855  0.   2.10967159   6.07900429   0.  
 0.  0.  10.21759605   1.16319525   2.90590048]

Was passiert Bild: (Z) macht es noch einfacher zu verstehen.

Mit Ausnahme des (weißen) Teils, in dem die Merkmale stark bleiben, wurde es schwarz. Wow, nur die Funktionen bleiben wunderschön! Leicht zu verstehen ~! Ist es so

5: Pooling: Pooling

Das gefaltete und aktivierte Bild wird gut mit Merkmalen extrahiert, daher ist es an der Zeit, die Abmessungen zu reduzieren. Im Fall von Pooling kann es sich eher um eine Komprimierung handeln.

Dimensionsreduzierung.py

def max_pool_2x2(x): 
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],                 
                         strides=[1, 2, 2, 1], padding='SAME') 
h_pool1 = max_pool_2x2(h_conv1)

Das Pooling ist etwas verwirrend, aber ksize = [1, 2, 2, 1] erzeugt einen 2x2-Pixel-Frame und strides = [1, 2, 2, 1] bewegt 2x2 Pixel. Ich werde fortsetzen. Im Fall von "tf.nn.max_pool" wird der größte Wert im Rahmen der durch "ksize" angegebenen Größe nach der Komprimierung als 1 Pixel angesehen. Diese Zahl ist leicht zu verstehen. Im Fall der Figur werden "6" für Rosa, "8" für Grün, "3" für Gelb und "4" für Blau als komprimierte Bilder erzeugt.

Zusätzlich zu "tf.nn.max_pool" gibt es auch "tf.nn.avg_pool", das den Durchschnittswert innerhalb des Rahmens annimmt. Funktionen tf.nn.avg_pool sind möglicherweise besser, wenn Sie so wie sie sind komprimieren möchten oder wenn die Positionsbeziehung von Leerzeichen sinnvoll ist, anstatt hauptsächlich zu komprimieren.

Schauen wir uns nun den wesentlichen Fall von MAIST an. Das oben aktivierte Bild: (Z) ist ein 14x14-Bild wie dieses durch Pooling. Es wurde für Menschen unmöglich, visuell zu beurteilen, aber es scheint, dass das Bild kleiner wurde, während nur die Merkmale gut blieben.

Danach wird der gleiche Vorgang noch einmal wiederholt und das Bild wird schließlich zu "[batch_num, 7, 7, 64]".

Zweites Mal.py

W_conv2 = weight_variable([5, 5, 32, 64])                   
b_conv2 = bias_variable([64])                              
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)  
h_pool2 = max_pool_2x2(h_conv2)                           

Wenn Sie sorgfältig darüber nachdenken, hat sich die Größe des Bildes verringert, aber das Zielbild hat sich auf 64 Funktionen erhöht. Dieser Bereich hängt von der Einstellung der Anzahl der Filter ab. Wenn Sie die Anzahl der Filter erhöhen, wird der Berechnungsprozess immer schwerer. Sie sollten ihn daher anpassen, während Sie die Spezifikationen des PCs und die Anzahl der Daten berücksichtigen.

Selbst wenn Sie einen Filter verwenden und dieser "[batch_num, 7, 7, 1]" lautet, können Sie trotzdem lernen. Natürlich ist es weniger genau, aber es ist immer noch besser als das Anfängermodell. Ungefähr zweimal.

6: Versteckte Ebene: Versteckte Ebene

Die Antwort nähert sich. Die verborgene Ebene führt nur Matrixoperationen aus, es ist also nicht so schwierig.

Versteckte versteckte Ebene.py

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])             
W_fc1 = weight_variable([3136, 1024]) #[7*7*64, 1024]3136 ist die Größe von Tensor,1024 ist angemessen. Meist 1024 oder 1024 in der Branche*Es scheint ein Vielfaches von n zu sein.
b_fc1 = bias_variable([1024])                               
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1) 
#Dropout                                    
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) 

Voller Funktionen ☆ Uhauha Tensor h_pool2: [batch_num, 7, 7, 64] Kehren Sie dies zunächst zu einem Vektor mit "tf.reshape (h_pool2, [-1, 7 * 7 * 64])" zurück. Sie müssen lediglich eine Matrixoperation mit dem Gewicht "W_fc1: [3136, 1024]" ausführen, eine Vorspannung hinzufügen und diese aktivieren.

Der Grund, warum wir keine Matrixberechnung bis zur Anzahl der Antworten gleichzeitig durchführen, besteht darin, dass wir dem Antwortabgleich näher kommen möchten, während die Funktionen so weit wie möglich belassen werden, und es scheint zu vermeiden, dass zu viel gelernt wird, das sich nur an Trainingsdaten anpasst.

Der Grund, warum Sie keine gute Antwort geben können, wenn Sie die Dimensionen zu stark zerstören / Die Rolle der verborgenen Ebene ist Siehe ** "Topologie und Klassifizierung" ** in Qiita: Neuronale Netze, Varianten, Topologien, übersetzt von @KojiOhki.

Eine Regressionsanalyse ist schwierig, wenn die Merkmalskorrelation zwischen Daten verschiedener Klassen stark ist oder abgedeckt wird, wenn sie durch Dimensionsreduktion nicht gut getrennt werden kann oder wenn sich die Determinante an einem anderen Ort befindet. Ich frage mich, ob das der Fall ist. Bestimmen Sie die Größe Ihrer Brüste nur anhand Ihres Gesichts Dies kann der Fall sein. Im Gegenteil, die Größe der Brüste kann aus der Stimme bekannt sein. Deshalb macht es Spaß, Deep Learning auszuprobieren.

Übermäßiges Lernen ist der Teil von h_fc1_drop = tf.nn.dropout (h_fc1, keep_prob), wird aber später nach dem Lernergebnis beschrieben.

7: Lernergebnis

Mit diesem Netzwerk betrug die Genauigkeit bei 8700 Schritten ** 87,15% **. Es war 28,79% im Anfängermodell, also habe ich wohl CNN gesagt.

10000steps.py

simple_maist 10000 steps accuracy 0.287933        

now MAIST-CNN...                                         
i 0, training accuracy 0 cross_entropy 1200.03     
i 100, training accuracy 0.02 cross_entropy 212.827
i 200, training accuracy 0.14 cross_entropy 202.12 
i 300, training accuracy 0.02 cross_entropy 199.995
i 400, training accuracy 0.14 cross_entropy 194.412
i 500, training accuracy 0.1 cross_entropy 192.861 
i 600, training accuracy 0.14 cross_entropy 189.393
i 700, training accuracy 0.16 cross_entropy 174.141
i 800, training accuracy 0.24 cross_entropy 168.601
i 900, training accuracy 0.3 cross_entropy 152.631 
...                   
i 9000, training accuracy 0.96 cross_entropy 8.65753         
i 9100, training accuracy 0.96 cross_entropy 11.4614         
i 9200, training accuracy 0.98 cross_entropy 6.01312         
i 9300, training accuracy 0.96 cross_entropy 10.5093         
i 9400, training accuracy 0.98 cross_entropy 6.48081         
i 9500, training accuracy 0.98 cross_entropy 6.87556         
i 9600, training accuracy 1 cross_entropy 7.201              
i 9700, training accuracy 0.98 cross_entropy 11.6251         
i 9800, training accuracy 0.98 cross_entropy 6.81862         
i 9900, training accuracy 1 cross_entropy 4.18039            
test accuracy 0.871565                                       

Wie gut findet die Deep Learning-Branche jetzt Funktionen und reduziert Dimensionen? Es kann möglich sein, durch Mastering ziemlich berühmt zu werden.

8: (Feinabstimmung) Lerndivergenz und Verhinderung von Überlernen

Lerndivergenz, durch die Sie den Überblick über das intelligente CNN-Modell verlieren

Wenn für Hiragana MAIST diesmal die Anzahl der Lernvorgänge wie im Experten-Tutorial auf 20000 eingestellt ist, sinkt die Genauigkeit der korrekten Antwortrate für die Lerndaten von etwa 15000 auf einmal auf etwa 2%. Ich kenne den detaillierten Mechanismus nicht, warum es plötzlich divergiert, aber wenn ich die Lernrate im Verlauf des Lernens nicht senke, wird der Gradient wahrscheinlich explodieren, wenn so etwas wie Cross Entropy die volle 0 oder Minus erreicht. Ich erwarte, dass es passiert.

Ist die vorbeugende Maßnahme dafür so?

Verhinderung von Lerndivergenzen.py

L =  1e-3 #Lernrate
train_step = tf.train.AdamOptimizer(L).minimize(cross_entropy)                                                             
for i in range(20000):                                               
  batch = random_index(50)                                           
  if i == 1000:   
    L = 1e-4      
  if i == 5000:   
    L = 1e-5      
  if i == 10000:  
    L = 1e-6      


...
i 19800, training accuracy 1 cross_entropy 6.3539e-05
i 19900, training accuracy 1 cross_entropy 0.00904318
test accuracy 0.919952         

Beim 20000-fachen Lernen beträgt die Genauigkeit 91,99%. Nun, ist es so etwas? Ich habe mir cross_entropy ungefähr alle 100 Male des Lernens angesehen und eine geeignete Bühne geschaffen. In der Realität kann diese Lernrate automatisch angepasst werden. Wenn Sie jedoch eine hohe Präzision anstreben, können Sie dies möglicherweise manuell tun.

Die Punktzahl in den Bewertungsdaten ist schlecht, nicht wahr? (`・ Ω ・ ´) [Verhinderung von Überlernen]

Der Code "h_fc1_drop = tf.nn.dropout (h_fc1, keep_prob)", der sich auf der verborgenen Ebene befand Es scheint sehr wichtig zu sein, Überlernen zu verhindern. Dies geschah, als ich es zusammen mit der Verhinderung von Lerndivergenzen weiter einstellte.

Prävention des Überlernens.py

for i in range(20000):
  batch = random_index(50)
#tune the learning rate
  if i == 1000: 
    L = 1e-4    
  if i == 3000: 
    L = 1e-5    
  if i == 7000: 
    L = 1e-6    
  if i == 10000:
    L = 1e-7    
  if i == 14000:
    L = 1e-8    
  if i == 19000:
    L = 1e-9    

#tune the dropout
  if i < 3000:                                                                                
    train_step.run(feed_dict={x: train_image[batch], y_: train_label[batch], keep_prob: 1})   
  elif i >= 3000 and i < 10000:                                                               
    train_step.run(feed_dict={x: train_image[batch], y_: train_label[batch], keep_prob: 0.3}) 
  elif i >= 10000 and i < 15000:                                                              
    train_step.run(feed_dict={x: train_image[batch], y_: train_label[batch], keep_prob: 0.1}) 
  elif i >= 15000 and i < 19000:                                                              
    train_step.run(feed_dict={x: train_image[batch], y_: train_label[batch], keep_prob: 0.05})
  else:                                                                                       
    train_step.run(feed_dict={x: train_image[batch], y_: train_label[batch], keep_prob: 0.8}) 

...
i 19900, training accuracy 1 cross_entropy 0.0656946
test accuracy 0.950418

** 95,04% ** in den Bewertungsdaten Es ist eine gute Idee, die Anzahl der Lernvorgänge zu erhöhen, solange das Lernen nicht abweicht. Wenn Sie jedoch versuchen, ein Format zu erstellen, das Sie vom Anfang bis kurz vor dem Ende sofort vergessen lässt, können Sie diese Genauigkeit erreichen.

Von den ersten ** 87,15% ** bis ** 95,04% ** war es meiner Meinung nach eine ziemlich gute Anpassung. Wenn das Modell funktioniert, kann es handwerklich sein.

Wenn viel Berechnungsverarbeitung erforderlich ist, dauert es einige Zeit. Wenn also die Genauigkeit der Bewertungsdaten verbessert werden kann, ist es besser, alle 1000 Lernschritte zu betrachten, damit ein Überlernen sofort erkannt werden kann. Unerwarteterweise betrug die Lerngenauigkeit des von mir erstellten Modells 80%, die Bewertungsdaten jedoch 20%. Dies hängt jedoch von der Anzahl der klassifizierten Klassen ab.

Zusammenfassung und nächstes Mal ...?

Wenn das Lernen mit CNN nicht gut funktioniert, erleichtert die Visualisierung das Verständnis struktureller Probleme. Die Visualisierung kann einfach durchgeführt werden, indem der Inhalt von Tensor mit sess.run empfangen und matplotlib verwendet wird.

Die folgende Site wird für diejenigen empfohlen, die die MNIST-Visualisierung und die detaillierte Verarbeitung sehen möchten. Was für ein Wahnsinn, Deep Learning mit JavaScript zu implementieren ConvNetJS - http://cs.stanford.edu/people/karpathy/convnetjs/demo/mnist.html

Wenn möglich, möchte ich das nächste Mal word2vec erklären, das die Basis von LSTM ist, das die Basis der Suchvorhersage ist, aber wann wird es sein? word2vec ist ein unterhaltsamer Algorithmus, den Web- (oder alle) Unternehmen problemlos auf die Datenanalyse anwenden können.

Ich bin jedoch der Meinung, dass je ausgefeilter die Modelle und die große Datenmenge sind, desto länger dauert es, bis Einzelpersonen dies auf ihren eigenen PCs tun, und desto höher ist das Limit **. Ich möchte etwas über Google Inception erklären, das das stärkste Bilderkennungsmodell ist, aber ich frage mich, ob es für mich, dem es an Geld mangelt, schwierig ist, den verteilten Tensorflow in einer Cloud-Umgebung zu verwenden!

Das ist alles für die Seite.

Aktien, Tweets, Likes, Hass, Kommentare usw. sind alle ermutigend, also bitte.

Wenn die Summmethode die vorherige Zeit überschreitet, machen wir es beim nächsten Mal. Ja, lass uns das machen.

• Hinzugefügt 2016.12.12 Ich habe eine Beschreibung von LSTM im Adventskalender geschrieben. > Wenn Sie dies verstehen können, können Sie dann die Verarbeitung natürlicher Sprache durchführen? Kommentar beim Berühren von RNN (LSTM) mit MNIST