Studiennotizen TF024: TensorFlow implementiert die Softmax-Regression (Regression), um handgeschriebene Ziffern zu erkennen

TensorFlow implementiert die Softmax-Regression, um handgeschriebene Ziffern zu erkennen. MNIST (Mixed National Institute of Standards and Technology-Datenbank), ein einfacher Datensatz für maschinelles Sehen, handgeschriebene Ziffern mit 28 x 28 Pixeln, nur Graustufenwertinformationen, der leere Teil ist 0, die Handschrift wird entsprechend der Farbtiefe von [0, 1] übernommen , 784 Dimensionen, Verwerfen zweidimensionaler Rauminformationen, Ziele sind in 10 Kategorien von 0 bis 9 unterteilt. Laden der Daten, data.read_data_sets, 55.000 Proben, Testsatz 10.000 Proben, Validierungssatz 5.000 Proben. Beispielanmerkungsinformationen, Beschriftung, 10-dimensionaler Vektor, 10 Arten der One-Hot-Codierung. Der Trainingssatz trainiert das Modell, der Validierungssatz testet den Effekt und der Testsatz bewertet das Modell (Genauigkeit, Rückruf, F1-Score).

Algorithmusdesign, Softmax-Regression trainiert das handschriftliche Ziffernerkennungsklassifizierungsmodell, schätzt die Kategoriewahrscheinlichkeit und verwendet die maximale Wahrscheinlichkeitszahl als Modellausgabeergebnis. Zur Bestimmung der Klassenwahrscheinlichkeit werden Klassenmerkmale hinzugefügt. Beim Modelllerntraining werden die Gewichte angepasst. Softmax, verschiedene Feature-Berechnungs-Exp-Funktionen, standardisiert (der Ausgabewahrscheinlichkeitswert aller Kategorien ist 1). y = softmax(Wx+b).

NumPy verwendet C, Fortran und ruft die Matrixoperationsbibliotheken openblas und mkl auf. Die dichten und komplexen Operationen von TensorFlow werden außerhalb von Python ausgeführt. Definieren Sie das Berechnungsdiagramm. Die Berechnungsoperation muss nicht jedes Mal zurück an Python übertragen werden. Alle Operationen werden außerhalb von Python ausgeführt.

Tensorfluss als TF importieren, TensorFlow-Bibliothek laden. less = tf.InteractiveSession(), erstellt eine InteractiveSession und registriert sie als Standardsitzung. Die Daten und Vorgänge verschiedener Sitzungen sind unabhängig voneinander. x = tf.placeholder(tf.float32, [None,784]), erstellen Sie einen Platzhalter zum Empfangen von Eingabedaten. Der erste Parameter ist der Datentyp und der zweite Parameter stellt die Datengröße der Tensorform dar. Keine. Die Anzahl der Eingaben ist unbegrenzt. Jede Eingabe ist ein 784-dimensionaler Vektor.

Tensor speichert Daten und verschwindet nach der Verwendung. Die Variable bleibt in Iterationen des Modelltrainings bestehen, existiert über einen langen Zeitraum und wird in jeder Iteration aktualisiert. Die variablen Objektgewichte und Bias des Softmax-Regressionsmodells werden auf 0 initialisiert. Das Modelltraining lernt automatisch geeignete Werte. Bei komplexen Netzwerken ist die Initialisierungsmethode wichtig. w = tf.Variable(tf.zeros([784, 10])), 784 Merkmalsdimensionen, 10 Kategorien. Label, ein 10-dimensionaler Vektor nach One-Hot-Codierung.

Softmax-Regressionsalgorithmus, y = tf.nn.softmax(tf.matmul(x, W) + b). tf.nn enthält eine große Anzahl neuronaler Netzwerkkomponenten. tf.matmul, Matrixmultiplikationsfunktion. TensorFlow implementiert automatisch Vorwärts- und Rückwärtsinhalte. Solange der Verlust definiert ist, leitet das Training automatisch einen Gradientenabstieg ab und schließt das automatische Lernen der Parameter des Softmax-Regressionsmodells ab.

Definieren Sie die Verlustfunktion, um die Klassifizierungsgenauigkeit des Problemmodells zu beschreiben. Je kleiner der Verlust, desto kleiner ist das Ergebnis der Modellklassifizierung im Vergleich zum wahren Wert und desto genauer ist es. Die Anfangsparameter des Modells sind alle Null, was zu einem Anfangsverlust führt. Das Trainingsziel besteht darin, Verluste zu reduzieren und die global optimale oder lokal optimale Lösung zu finden. Kreuzentropie- und Verlustfunktionen werden häufig bei Klassifizierungsproblemen verwendet. y vorhergesagte Wahrscheinlichkeitsverteilung, y' wahre Wahrscheinlichkeitsverteilung (Label One-Hot-Codierung), bestimmen die Genauigkeit der Vorhersage der wahren Wahrscheinlichkeitsverteilung durch das Modell. cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1])). Definieren Sie den Platzhalter und geben Sie die echte Beschriftung ein. tf.reduce_sum berechnet die Summe und tf.reduce_mean berechnet den Durchschnitt jedes Batch-Datenergebnisses.

Definieren Sie den Optimierungsalgorithmus, stochastischen Gradientenabstieg SGD (Stochastic Gradient Descent). Automatische Ableitung basierend auf dem Berechnungsdiagramm, Training basierend auf dem Back Propagation-Algorithmus und iterative Aktualisierung der Parameter in jeder Runde, um Verluste zu reduzieren. Ein Kapselungsoptimierer wird bereitgestellt, um die Feed-Daten in jeder Runde zu iterieren. TensorFlow ergänzt die Operation (Operation) automatisch im Hintergrund, um Backpropagation und Gradientenabstieg zu implementieren. train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy). Rufen Sie tf.train.GradientDescentOptimizer auf, setzen Sie die Lerngeschwindigkeit auf 0,5, legen Sie die Kreuzentropie des Optimierungsziels fest und rufen Sie den Trainingsvorgang train_step ab.

tf.global_variables_initializer().run(). Globaler TensorFlow-Parameterinitialisierer tf.golbal_variables_initializer.

batch_xs,batch_ys = mnist.train.next_batch(100). Trainingsbetrieb train_step. Jedes Mal werden 100 Proben zufällig aus dem Trainingssatz ausgewählt, um einen Mini-Batch zu bilden, dem Platzhalter zugeführt und train_step-Trainingsproben werden aufgerufen. Durch die Verwendung einer kleinen Anzahl von Proben für das Training führt der stochastische Gradientenabstieg zu einer schnelleren Konvergenz. Alle Proben werden jedes Mal trainiert, was einen hohen Rechenaufwand erfordert und es schwierig macht, aus dem lokalen Optimum herauszuspringen.

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmzx(y_,1)), überprüfen Sie die Modellgenauigkeit. tf.argmax ermittelt die Maximalwertsequenznummer aus dem Tensor, tf.argmax(y,1) ermittelt die maximale vorhergesagte Zahlenwahrscheinlichkeit und tf.argmax(y_,1) ermittelt die wahre Zahlenkategorie der Stichprobe. tf.equal bestimmt, ob die vorhergesagte Zahlenkategorie korrekt ist, und gibt zurück, ob die Berechnungsklassifizierungsoperation korrekt ist.

accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)), zählt die Vorhersagegenauigkeit aller Stichproben. tf.cast konvertiert den Ausgabewerttyp „correct_prediction“.

print(accuracy.eval({x: mnist.test.images,y_: mnist.test.labels})). Testen Sie Dateneigenschaften, kennzeichnen Sie den Eingabebewertungsprozess und berechnen Sie die Genauigkeit des Modelltestsatzes. Softmax Regression MNIST-Datenklassifizierung und -erkennung, die durchschnittliche Genauigkeit des Testsatzes beträgt etwa 92 %.

TensorFlow implementiert einfache Maschinenalgorithmusschritte:
1､Definieren Sie die Algorithmusformel und die Vorwärtsberechnung des neuronalen Netzwerks.
2､Definieren Sie den Verlust, wählen Sie den Optimierer aus und geben Sie den Optimierer an, um den Verlust zu optimieren.
3､Iterative Trainingsdaten.
4､Bewertungsgenauigkeit des Testsatzes und des Verifizierungssatzes.

Die definierte Formel ist nur das Berechnungsdiagramm. Die Berechnung wird nur ausgeführt, wenn die Laufmethode und die Feed-Daten aufgerufen werden.

    <span style="color: #0000ff">from</span> tensorflow.examples.tutorials.mnist <span style="color: #0000ff">import</span><span style="color: #000000"> input_data
    mnist </span>= input_data.read_data_sets(<span style="color: #800000">"</span><span style="color: #800000">MNIST_data/</span><span style="color: #800000">"</span>, one_hot=<span style="color: #000000">True)
    </span><span style="color: #0000ff">print</span><span style="color: #000000">(mnist.train.images.shape, mnist.train.labels.shape)
    </span><span style="color: #0000ff">print</span><span style="color: #000000">(mnist.test.images.shape, mnist.test.labels.shape)
    </span><span style="color: #0000ff">print</span><span style="color: #000000">(mnist.validation.images.shape, mnist.validation.labels.shape)
    </span><span style="color: #0000ff">import</span><span style="color: #000000"> tensorflow as tf
    sess </span>=<span style="color: #000000"> tf.InteractiveSession()
    x </span>= tf.placeholder(tf.float32, [None, 784<span style="color: #000000">])
    W </span>= tf.Variable(tf.zeros([784, 10<span style="color: #000000">]))
    b </span>= tf.Variable(tf.zeros([10<span style="color: #000000">]))
    y </span>= tf.nn.softmax(tf.matmul(x, W) +<span style="color: #000000"> b)
    y_ </span>= tf.placeholder(tf.float32, [None, 10<span style="color: #000000">])
    cross_entropy </span>= tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1<span style="color: #000000">]))
    train_step </span>= tf.train.GradientDescentOptimizer(0.5<span style="color: #000000">).minimize(cross_entropy)
    tf.global_variables_initializer().run()
    </span><span style="color: #0000ff">for</span> i <span style="color: #0000ff">in</span> range(1000<span style="color: #000000">):
        batch_xs, batch_ys </span>= mnist.train.next_batch(100<span style="color: #000000">)
        train_step.run({x: batch_xs, y_: batch_ys})
    correct_prediction </span>= tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1<span style="color: #000000">))
    accuracy </span>=<span style="color: #000000"> tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    </span><span style="color: #0000ff">print</span>(accuracy.eval({x: mnist.test.images, y_: mnist.test.labels}))

Referenzmaterialien:
"TensorFlow Practice"

Willkommen bei der Bezahlung der Beratung (150 Yuan pro Stunde), mein WeChat: qingxingfengzi

Das obige ist der detaillierte Inhalt vonStudiennotizen TF024: TensorFlow implementiert die Softmax-Regression (Regression), um handgeschriebene Ziffern zu erkennen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!