[PYTHON] Berühren Sie das Objekt des neuronalen Netzes

Ich habe Tensorflow neulich zum ersten Mal berührt, aber diesmal habe ich ein kleines neuronales Netzobjekt berührt. Zuerst habe ich hochrangige Herausforderungen ausprobiert, um verschiedene Gruppen auszuprobieren, aber es hat überhaupt nicht funktioniert, deshalb werde ich super-super-rudimentäre Dinge schreiben, um die Grundlagen zu bewerten.

Ich habe es berührt tensorflow.layers.dense Dieser Teil. Anscheinend entspricht es der "Schicht" des Newral Network. Als ich danach suchte, fand ich den folgenden Beispielsatz.

hidden1 = tf.layers.dense(x_ph, 32, activation=tf.nn.relu)

Wenn Sie dies bauen, scheint es, dass Sie ziemlich komplizierte Dinge tun können. Dieses Mal werde ich jedoch einfach das folgende Modell betrachten. Es gibt zwei Eingänge und einen Ausgang.

Ich glaube nicht, dass es mehr ein neuronales Netzwerk ist, aber ... Ich denke, ich muss das verstehen, also fange ich von hier aus an.

Lassen Sie uns zunächst eine Schicht eines neuronalen Netzwerks erstellen.

newral_out = tf.layers.dense(x_ph, 1)

Damit wird die Eingabe durch x_ph definiert und die Anzahl der Ausgaben scheint eins zu sein. Es scheint, dass Sie mit Optionen verschiedene Dinge tun können, aber dieses Mal werde ich versuchen, dass es sich wie eine bloße lineare Verbindung anfühlt. x_ph ist ein Platzhalter eines Felds für die Dateneingabe, und diesmal wird es unten definiert.

x_ph = tf.placeholder(tf.float32, [None, 2])

Die Größe von [Keine 2] und Keine bedeutet, dass Sie eine beliebige Anzahl von Samples einfügen können, und 2 ist die Anzahl der einzugebenden Variablen. Daher setzen wir sie hier auf 2 (X1, X2).

Dieses Mal entspricht die Ausgabe der folgenden Formel ganz einfach y1.

y_1 = w_1 x_1 + w_2 x_2 + w_0

Ist es möglich, w_1, w_2, w_0 gut abzuschätzen, indem willkürlich (x1, x2) und y1 entsprechend eingefügt werden? Es ist ein wirklich einfaches Problem.

Zu diesem Zeitpunkt kann der Code des ersten Beispiels so verwendet werden, wie er ist. Daher ist er wahrscheinlich sehr einfach zu implementieren und sieht wie folgt aus.

# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(newral_out - y_ph))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)

Ist es danach in Ordnung, wenn ich Sie das lernen lasse?

# initialize tensorflow session
sess = tf.Session()
sess.run(tf.global_variables_initializer())

for k in range(101):
    # shuffle train_x and train_y
    n = np.random.permutation(len(train_x))
    train_x = train_x[n]
    train_y = train_y[n].reshape([len(train_y), 1])

    # execute train process
    sess.run(train,feed_dict = {
                     x_ph: train_x, # x is input data
                     y_ph: train_y # y is true data
                     })

Dies scheint einmal zu funktionieren, aber da es eine gute Idee ist, würde ich gerne wissen, wie sich die Parameter des Newral Network verhalten. Es scheint eine Möglichkeit zu geben, es direkt zu lesen, aber es scheint schwierig zu sein. Da es ein einfaches Problem ist, habe ich über meine eigene Analysefunktion nachgedacht.

Die Idee ist, w0, w1, w2 nach der Methode der kleinsten Quadrate zu finden. Stellen Sie sich das neuronale Netzwerk als virtuelle lineare Approximationsgleichung vor und überprüfen Sie seine Parameter. Geben Sie zuerst die Daten ein

{{x_1}_k},{{x_2}_k}

Und stellen Sie die durch Newral abgeleiteten Informationen ein

{y^{(new)}}_k = Newral({{x_1}_k},{{x_2}_k})

Wird besorgt. Dieses {y ^ {(neu)}} _k enthält eine definitive Zahl. Da die Schätzung des neuronalen Netzes möglicherweise eine Verzerrung aufweist, ist die folgende Gleichung zu berücksichtigen.

{y^{(new)}}_k = w_1{x_1}_k + w_2{x_2}_k + w0

Zu diesem Zeitpunkt sind w_1, w_2, w_0 unbekannt und die anderen werden bestimmt. Hier ist es für jedes k wie folgt, wenn es als simultane Gleichung betrachtet wird.

\left(
\begin{matrix}
{y^{(new)}}_1 \\
... \\
{y^{(new)}}_K \\
\end{matrix}
\right)
 = 
\left(
\begin{matrix}
{x_1}_1 & {x_2}_1 & 1 \\
... & ... \\
{x_1}_K & {x_2}_K & 1 \\
\end{matrix}
\right)
\left(
\begin{matrix}
w_1 \\
w_2 \\
w_0 \\
\end{matrix}
\right)

An diesem Punkt haben wir ein einfaches Problem der kleinsten Quadrate. Der Einfachheit halber

A
 = 
\left(
\begin{matrix}
{x_1}_1 & {x_2}_1 & 1 \\
... & ... \\
{x_1}_K & {x_2}_K & 1 \\
\end{matrix}
\right)

Und dann,

\left(
\begin{matrix}
w_1 \\
w_2 \\
w_0 \\
\end{matrix}
\right)
=
\left(
A^T A
\right)^{-1}
A^T
\left(
\begin{matrix}
{y^{(new)}}_1 \\
... \\
{y^{(new)}}_K \\
\end{matrix}
\right)

Es scheint also, dass die Parameter erhalten werden können. Wenn Sie beim Erstellen eines echten Werts w_1, w_2, w_0 auf einen numerischen Wert setzen und beobachten, wie Sie sich der richtigen Antwort nähern, werden Sie das Gefühl haben, den Inhalt des neuronalen Netzwerks ein wenig zu verstehen. (Lacht)

Also werde ich den gesamten Code einfügen.

import numpy as np
#import matplotlib.pyplot as plt
import tensorflow as tf


# deta making???
N = 50
x = np.random.rand(N,2)
# true param???
w = np.array([0.5,0.5]).reshape(2,1)
# sum > 1.0 > 1 : else > 0
#y = np.floor(np.sum(x,axis=1))
y = np.matmul(x,w)
train_x = x
train_y = y


# make placeholder
x_ph = tf.placeholder(tf.float32, [None, 2])
y_ph = tf.placeholder(tf.float32, [None, 1])
# create newral parameter(depth=1,input:2 > output:1)
newral_out = tf.layers.dense(x_ph, 1)


# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(newral_out - y_ph))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)


# initialize tensorflow session
sess = tf.Session()
sess.run(tf.global_variables_initializer())


for k in range(101):

    
    if np.mod(k,10) == 0:
        # get Newral predict data
        y_newral = sess.run( newral_out
                         ,feed_dict = {
                         x_ph: x, #Ich habe die Eingabedaten in x gesetzt
                         y_ph: y.reshape(len(y),1) #Ich habe die richtigen Antwortdaten in y eingegeben
                         })
        
        # check for newral_parameter(w0,w1,w2)???
        # 
        x_ext = np.hstack([x,np.ones(N).reshape(N,1)])
        A = np.linalg.inv( np.matmul(np.transpose(x_ext),x_ext) )
        A = np.matmul(A,np.transpose(x_ext))
        w_ext = np.matmul(A,y_newral)
        
        # errcheck??? ([newral predict] vs [true value])
        err = y_newral - y
        err = np.matmul(np.transpose(err),err)
        
        
        # check y_newral
        # check LS solution(approaching to NewralNet Parameter)
        # check predict NewralParam
        print('[%d] err:%.5f w1:%.2f w2:%.2f bias:%.2f' % (k,err,w_ext[0],w_ext[1],w_ext[2]))


    # shuffle train_x and train_y
    n = np.random.permutation(len(train_x))
    train_x = train_x[n]
    train_y = train_y[n].reshape([len(train_y), 1])

    # execute train process
    sess.run(train,feed_dict = {
                     x_ph: train_x, # x is input data
                     y_ph: train_y # y is true data
                     })

Ich habe nichts geschrieben, aber ich habe beschlossen, den Fehler durch die Summe der Quadrate zu berechnen. Betrachtet man dieses Ergebnis ... ???

[0] err:1.06784 w1:0.36 w2:0.36 bias:0.00
[10] err:0.02231 w1:0.45 w2:0.45 bias:0.06
[20] err:0.00795 w1:0.47 w2:0.47 bias:0.03
[30] err:0.00283 w1:0.48 w2:0.48 bias:0.02
[40] err:0.00101 w1:0.49 w2:0.49 bias:0.01
[50] err:0.00036 w1:0.49 w2:0.49 bias:0.01
[60] err:0.00013 w1:0.50 w2:0.50 bias:0.00
[70] err:0.00005 w1:0.50 w2:0.50 bias:0.00
[80] err:0.00002 w1:0.50 w2:0.50 bias:0.00
[90] err:0.00001 w1:0.50 w2:0.50 bias:0.00
[100] err:0.00000 w1:0.50 w2:0.50 bias:0.00

Da der wahre Parameter w1 = 0,5, w2 = 0,5, Vorspannung (w0) = 0 ist, scheint er nach etwa 30-maligem Drehen zu einem guten Gefühl zu konvergieren.

Das neuronale Netzwerk schien kompliziert zu sein, aber wenn man es so einfach macht, sieht es aus wie eine einfache lineare Kopplung und ein Ersatzschaltbild. Es mag ein Ergebnis sein, das für den Experten offensichtlich ist, aber es war eine große Ernte für mich.

Mit diesem Gefühl werde ich das nächste Mal etwas Komplizierteres ausprobieren!