[PYTHON] [TensorFlow] Minimale quadratische lineare Regression durch Gradientenabstiegsmethode (steilste Abstiegsmethode)

TensorFlow: Erster Schritt

TensorFlow ist eine skalierbare, plattformübergreifende Programmierschnittstelle zum Implementieren und Ausführen von Algorithmen für maschinelles Lernen ........

Kurz zusammengefasst scheint es sich um ein Paket zu handeln, das einen Verarbeitungsablauf erstellt und ausführt, der als Berechnungsdiagramm bezeichnet wird. PyTorch und Keras holen auf, aber TensorFlow ist immer noch sehr beliebt.

Es ist schwieriger zu debuggen und schwerer zu verstehen als Keras. Tatsächlich scheint TensorFlow 2.0 veröffentlicht worden zu sein, das einfach angewendet werden kann, wahrscheinlich aufgrund der oben genannten Punkte.

In diesem Artikel werde ich die frühe TensorFlow-Grammatik verwenden. Seien Sie versichert, auch wenn Sie TensorFlow 2.0 installiert haben. Sie können mit folgendem Code konvertieren ....!

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

Der Schreibstil ist ungefähr wie folgt.

Lassen Sie es uns vorerst laufen. Wenn Sie das TensorFlow-Paket installieren und versuchen, es auszuführen, wird häufig ein unverständlicher Fehler angezeigt. Deinstallieren Sie es daher gnadenlos → installieren Sie es.

python

import os
import numpy as np
import tensorflow as tf
  
g = tf.Graph()
 
with g.as_default():
    x = tf.placeholder(dtype=tf.float32, shape=(None), name='x') #Streit
    w = tf.Variable(2.0, name='weight') #Variable ①
    b = tf.Variable(0.7, name='bias')   #Variable ②
    z=w*x + b
    init=tf.global_variables_initializer()     #Variable Initialisierung(tf.Sie können es in Sitzung definieren, aber es ist hier einfacher zu handhaben)
  
with tf.Session(graph=g) as sess:
    sess.run(init)                             #Führen Sie eine Variableninitialisierung durch
    for number in [1.0, 0.6, -1.8]:
        z = sess.run(z, feed_dict={x:number})  # z= w * x +Führen Sie b aus
        print(z)                               #Drucken Sie das Verarbeitungsergebnis aus

z = sess.run(z, feed_dict={x:number})

Nur dieser Teil wird kurz erklärt. sess.run (Name der Variablen, auf die Sie zugreifen möchten, feed_dict = {Argument: Wert, den Sie an das Argument übergeben möchten})

Lass uns stetig gehen. Als nächstes betreiben Sie das Array (Tensor). In TensorFlow wird der entlang der Kante fließende Wert im Berechnungsdiagramm als Tensor bezeichnet. Es ist nur ein Tensorfluss. Tensole können als Skalare, Vektoren und Matrizen interpretiert werden. Zum Beispiel ist die Prozedur wie folgt. Lassen Sie uns nun den Tensor mit TensorFlow betreiben.

python

g = tf.Graph()
with g.as_default():
    x = tf.placeholder(dtype=tf.float32, shape=(None,2,3), name='input_x') #Argumente, die den Tensor erhalten
    x2 = tf.reshape(x,shape=(-1,6),name='x2') #Transformieren Sie das empfangene Argument x mit der Umformmethode
     
    print(x2) #Definition der Ausgabevariablen
     
    xsum=tf.reduce_sum(x2,axis=0,name='col_sum') #Summe jeder Spalte
    xmean=tf.reduce_mean(x2,axis=0,name='col_mean') #Durchschnitt für jede Spalte
 
with tf.Session(graph=g) as sess:
    x_array = np.arange(18).reshape(3,2,3) #Erstellen Sie ein Array
    print('Column Sums:\n', sess.run(xsum, feed_dict={x:x_array}))   #Geben Sie die Summe jeder Spalte aus
    print('Column Means:\n', sess.run(xmean, feed_dict={x:x_array})) #Geben Sie den Durchschnitt jeder Spalte aus

tf.reshape(x,shape=(-1,6),name='x2') Der Punkt hier ist, dass -1 für die Form angegeben wird.

Dies bedeutet, dass die Typdefinition unentschlossen ist und Sie sie entsprechend dem Eingabearray konvertieren sollten.

TensorFlow: Implementierung der linearen Regression im kleinsten Quadrat

Zuallererst ist die minimale quadratische lineare Regression von oben. ① Berechnen Sie den vorhergesagten Wert mit der Formel y = w * x + b ② (Richtiger vom Antwortetikett vorhergesagter Wert) ^ 2 ③ Finden Sie den Durchschnittswert von ② ④ Verwenden Sie ③, um w und b zu finden ⑤ Wiederholen Sie dies für einige Epochen

Infolgedessen kann gesagt werden, dass der Kostenwert konvergiert hat, wenn er sich auf den globalen Mindestwert einstellt. Es sieht so aus, als hätte ich unten versucht, manuell mit Excel zu berechnen.

Und eine gemeinsame Figur. Dies zeigt, wie der Kostenwert (gelber Teil von Excel) dargestellt und konvergiert wird. Die Kostenfunktion einer linearen Funktion wird zu einer teilbaren konvexen Funktion.

Werfen wir einen Blick auf den aktuellen Code! !! Bereiten Sie zunächst die Trainingsdaten vor

python

#Trainingsdaten
X_train = np.arange(10).reshape((10, 1))
y_train = np.array([1.0, 1.3, 3.1,2.0, 5.0, 6.3, 6.6, 7.4, 8.0, 9.0])
  
#Lineare Regressionsmodelldarstellung
plt.scatter(X_train, y_train, marker='s', s=50,label='Training Data')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.tight_layout()
plt.show()

Ja, ich habe versucht, mit Matplotlib zu zeichnen!

Bereiten Sie als Nächstes die TfLinreg-Klasse vor.

python

class TfLinreg(object):
     
    #Konstrukteur
    def __init__(self, x_dim, learning_rate=0.01, random_seed=None):
        self.x_dim = x_dim
        self.learning_rate = learning_rate
        self.g = tf.Graph()
         
        with self.g.as_default():
            tf.set_random_seed(random_seed)
            self.build()
             
            #Variabler Initialisierer
            self.init_op = tf.global_variables_initializer()
     
    def build(self):
         
        #Platzhalter definieren
        self.X = tf.placeholder(dtype=tf.float32, shape=(None,self.x_dim), name='x_input')
        self.y = tf.placeholder(dtype=tf.float32, shape=(None), name='y_input')
         
        # tf.zeros:Matrix mit allen 0 Elementen
        #1x1 Tensor
        w = tf.Variable(tf.zeros(shape=(1)), name='weight')
        b = tf.Variable(tf.zeros(shape=(1)), name='bias')
         
        self.w = w
        self.b = b
         
        #Berechnen Sie den vorhergesagten Wert
        # tf.squeeze:Eine Funktion, die eine Dimension entfernt und den Tensor um eins senkt
        self.test = w * self.X + b
        self.z_net = tf.squeeze(w * self.X + b, name='z_net')
         
        #Tatsächlicher Wert-Voraussichtlicher Wert
        # tf.square:Nimm das Quadrat für jedes Element
        sqr_errors = tf.square(self.y - self.z_net, name='sqr_errors')
        self.sqr_errors = sqr_errors
         
        #Kostenfunktion
        # tf.reduce_mean:Eine Funktion, die den Durchschnittswert der Zahlen in der angegebenen Liste berechnet
        self.mean_cost = tf.reduce_mean(sqr_errors, name='mean_cost')
         
        ##Erstellen Sie einen Optimierer
        # GradientDescentOptimizer:Die steilste Abstiegsmethode
        optimizer = tf.train.GradientDescentOptimizer(
            learning_rate=self.learning_rate,
            name='GradientDescent'
        )
         
        #Verlustfunktionsgradient(Gewicht und Neigung)Berechnung
        self.optimizer = optimizer.minimize(self.mean_cost)

Zu diesem Zeitpunkt haben wir gerade die Klasse definiert, sodass keine spezifischen Zahlen festgelegt wurden. Ein Punkt hier. Es gibt verschiedene Arten von Gradientenabstiegsmethoden.

· Gradientenabstieg ・ Stochastischer Gradientenabstieg - SDG ・ Minibatch SGD --MSGD

Im Gegensatz zur Methode mit dem steilsten Abstieg werden die Parameter aktualisiert, nachdem die Summe aller Fehler erfasst wurde. Die probabilistische Gradientenabstiegsmethode aktualisiert das Gewicht für jedes Datenelement. Der Mini-Batch ist eine Zwischenexistenz zwischen den beiden, und das Bild zeigt, dass für jede Batch-Nummer eine große Datenmenge geschnitten und ausgeführt wird.

Dann fahre fort. Rufen Sie zunächst den Konstruktor auf, um eine Instanz zu erstellen.

python

#Modellinstanziierung
lrmodel = TfLinreg(x_dim=X_train.shape[1], learning_rate=0.01)

Dann lerne

python

###Lernen
# self.optimizer
def train_linreg(sess, model, X_train, y_train, num_epochs=10):
    #Variable Initialisierung
    sess.run(model.init_op)
    training_costs=[]
 
    #Gleiches X._Zug 10 mal wiederholen
    for i in range(num_epochs):     
        """
        model.optimizer:Wenden Sie die Schnellabstiegsmethode an
        model.X:Trainingsdaten(Anzahl der Stockwerke 2)
        model.y:Richtige Antwortdaten(Anzahl der Stockwerke 1)
        model.z_net:Voraussichtlicher Wert(w * self.X +Berechnet aus b)
        model.sqr_errors:Tatsächlicher Wert-Voraussichtliches Quadrat
        model.mean_cost:Durchschnittswert des quadratischen Fehlers
        model.w:Gewicht nach dem Update
        model.b:Bias nach dem Update
        """
        _,X,y,z_net,sql_errors,cost,w,b= sess.run([
            model.optimizer,
            model.X,
            model.y,
            model.z_net,
            model.sqr_errors,
            model.mean_cost,
            model.w,
            model.b,
        ],feed_dict={model.X:X_train, model.y:y_train}) #Wiederholen Sie das gleiche 10 Mal
         
        print('  ')
        print(X)
        print(y)
        print(z_net)
        print(sql_errors)
        print(cost)
        print(w)
        print(b)
         
        training_costs.append(cost)
         
    return training_costs

model.optimizer Die steilste Abstiegsmethode wird bei ausgeführt.

Ich war ziemlich verwirrt, dass w und b die Gewichte aktualisiert haben. Die Ausgabe ist also

[0.60279995] [0.09940001] Die erste Vorhersage wird jedoch bei [0] [0] durchgeführt.

Ich werde es sofort bewegen.

python

sess = tf.Session(graph=lrmodel.g)
training_costs = train_linreg(sess, lrmodel, X_train, y_train)

Zeichnen wir den Kostenwert.

python

plt.plot(range(1,len(training_costs) + 1), training_costs)
plt.tight_layout()
plt.xlabel('Epoch')
plt.ylabel('Training Cost')
#plt.savefig('images/13_01.png', dpi=300)
plt.show()

...! Du hast es geschafft, es ist konvergiert! !!

Als nächstes machen wir eine Vorhersage. Die Vorhersage ist nicht schwierig, da nur der vorhergesagte Wert (z_net) aufgerufen wird. Es wird ausgeführt, indem ein Tensor zweiter Ordnung in das Argument x_test eingefügt wird.

python

###Prognose
# model.z_net
def predict_linreg(sess, model, X_test):
    y_pred = sess.run(model.z_net, feed_dict={model.X:X_test})
    return y_pred

Lassen Sie uns abschließend das mit den Trainingsdaten erstellte Modell visualisieren.

python

###Lineare Regressionsmodelldarstellung
#Trainingsdaten
plt.scatter(X_train, y_train, marker='s', s=50,label='Training Data')
 
#Ausgabe des linearen Regressionsmodells unter Verwendung von Trainingsdaten
plt.plot(range(X_train.shape[0]), predict_linreg(sess, lrmodel, X_train),color='gray'
         , marker='o', markersize=6, linewidth=3,label='LinReg Model')
 
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.tight_layout()
plt.show()

Die Ausrichtung ist schön gezeichnet ...........! Das war's für diese Zeit.