[PYTHON] Ungefähre Sinusfunktion mit TensorFlow

Ich werde ein Programm erklären, das sich der Sündenfunktion annähert und gleichzeitig die Verwendung von TensorFlow untersucht.

Lernmodell

Parameterdefinition

Über X (Eingabewert) und t (Lehrerdaten). Speichern Sie die Trainingssatzdaten im Platzhalter Zum Beispiel repräsentiert [Keine, 5] eine Matrix von [beliebig x 5]. t wird auf [None, 1] gesetzt, damit die Anzahl der Daten beliebig erfasst werden kann.

Über w (Gewicht). Da es der zu optimierenden Variablen entspricht, wird es als Instanz der Klasse tf.Variable definiert. Erstellen Sie eine 5x1-Matrix mit dem Anfangswert 0.

Mit diesen wird ein Netzwerk aus Eingangsschicht 1, Zwischenschicht 5 und Ausgangsschicht 1 erzeugt.

x=tf.placeholder(tf.float32,[None,5])
w=tf.Variable(tf.zeros([5,1]))
t=tf.placeholder(tf.float32,[None,1])

eine Formel

Der Ausdruck von y = Xw wird wie folgt ausgedrückt.

y=tf.matmul(x,w)

tf.matmul ist eine Funktion, die die Matrix multipliziert und den zuvor definierten Platzhalter x und die Variable w verwendet. Es wurde noch kein bestimmter Wert eingegeben und y wurde nicht bestimmt.

Fehlerfunktion

Die Differenz zwischen den Lehrerdaten t und der Ausgabe y ist die Summe der Quadrate. Wir werden lernen, diesen quadratischen Fehler zu minimieren. Wählen Sie zu diesem Zeitpunkt auch den Optimierungsalgorithmus aus.

loss=tf.reduce_sum(tf.square(y-t))
train_step=tf.train.AdamOptimizer().minimize(loss)

Durchführung von Schulungen

Sitzung vorbereiten

Wir werden die Variablen, die der Variablen entsprechen, unter Verwendung der "Sitzung" berechnen, die die Ausführungsumgebung des Trainingsalgorithmus darstellt. Bereiten Sie zunächst eine neue Sitzung vor und initialisieren Sie Variable.

sess=tf.Session()
sess.run(tf.initialize_all_variables())

Zuordnung des Trainingsdatensatzes

Ersetzen Sie die Trainingssatzdaten durch den Platzhalter. train_t sind die tatsächlichen Daten.

train_t=np.array([np.sin(2.0*np.pi*i/11) for i in range(12)])
train_t=train_t.reshape([12,1])

train_x=np.zeros([12,5])
for row,m in enumerate(range(1,13)):
    for col,n in enumerate(range(0,5)):
        train_x[row][col]=m**n

Implementierung der Optimierung

Führen Sie den definierten Trainingsalgorithmus train_step aus, um die Gewichte zu korrigieren. Zu diesem Zeitpunkt wird in placeholder mit feed_dict ein bestimmter Wert festgelegt. Sie können den Verlust auch innerhalb einer Sitzung auswerten und den aktuellen Wert abrufen, z. B. loss_val. Dann wird der Wert des Parameters zum Zeitpunkt nach dem Stoppen des Trainings (nach dem Verlassen der for-Schleife) ausgegeben.

i=0
for _ in range(100000):
    i+=1
    sess.run(train_step,feed_dict={x:train_x,t:train_t})
    if i % 1000==0:
        loss_val=sess.run(loss,feed_dict={x:train_x,t:train_t})
        print ('Step:%d, Loss:%f'%(i,loss_val))

w_val=sess.run(w)
print w_val

Prüfung

Die Kurve des Testergebnisses wird nach folgender Formel ausgegeben. y(x)=w0+w1x+w2x^2+w3x^3+w4x^4

def predict(x):
    result=0.0
    for n in range(0,5):
        result+=w_val[n][0]* x**n
    return result

Ergebnis

Wenn die mittlere Schicht 5 Schichten umfasst und die Anzahl der Lernvorgänge 10.000-mal beträgt Obwohl es von der Handlung abweicht, denke ich, dass es grob angenähert werden kann.

Versuchen Sie, die Anzahl der Zwischenschichten zu ändern ... Zwischenschicht 6 Schichten: Es hat sich mehr verschoben.

Zwischenschicht 4 Schichten: Es ist näher als 5 Schichten.

Es ist auch wichtig, die entsprechende Anzahl von Zwischenschichten (Hyperparameter) anzugeben. ..

Vollständiger Code

sin.py

#-*- coding:utf-8 -*-
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

x=tf.placeholder(tf.float32,[None,5]) 
w=tf.Variable(tf.zeros([5,1]))

y=tf.matmul(x,w)

t=tf.placeholder(tf.float32,[None,1])
loss=tf.reduce_sum(tf.square(y-t))
train_step=tf.train.AdamOptimizer().minimize(loss)

sess=tf.Session()
sess.run(tf.initialize_all_variables())

train_t=np.array([np.sin(2.0*np.pi*i/11) for i in range(12)])
train_t=train_t.reshape([12,1])

train_x=np.zeros([12,5])
for row,m in enumerate(range(1,13)):
    for col,n in enumerate(range(0,5)):
        train_x[row][col]=m**n

i=0
for _ in range(100000):
    i+=1
    sess.run(train_step,feed_dict={x:train_x,t:train_t})
    if i % 1000==0:
        loss_val=sess.run(loss,feed_dict={x:train_x,t:train_t})
        print ('Step:%d, Loss:%f'%(i,loss_val))

w_val=sess.run(w)
print w_val

def predict(x):
    result=0.0
    for n in range(0,5):
        result+=w_val[n][0]* x**n
    return result

fig=plt.figure()
subplot=fig.add_subplot(1,1,1)
subplot.set_xlim(1,12)
subplot.scatter(range(1,13),train_t)
linex=np.linspace(1,12,100)
liney=predict(linex)
subplot.plot(linex,liney)
plt.show()