Touchez l'objet du réseau neuronal

J'ai touché Tensorflow pour la première fois l'autre jour, mais cette fois j'ai touché un petit objet de réseau neuronal. Au début, j'ai essayé des défis de haut niveau pour essayer différents groupes, mais cela n'a pas du tout fonctionné, donc j'écrirai des choses super-super rudimentaires dans l'esprit de valoriser les bases.

Je l'ai touché tensorflow.layers.dense Cette partie. Apparemment, cela correspond à la "couche" du réseau Newral. Quand je l'ai recherché, j'ai trouvé la phrase d'exemple suivante.

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

Si vous construisez cela, il semble que vous puissiez faire des choses assez compliquées. Cependant, cette fois, je considérerai simplement le modèle suivant. Il y a deux entrées et une sortie.

Je ne pense plus que ce soit un réseau de neurones, mais ... Je pense que je dois comprendre cela, alors je vais commencer par là.

Tout d'abord, créons une couche de réseau neuronal.

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

Avec cela, l'entrée est définie par x_ph, et le nombre de sorties semble être un. Il semble que vous puissiez faire différentes choses avec des options, mais cette fois, je vais essayer de donner l'impression que cela ressemble à une simple connexion linéaire. x_ph est un espace réservé d'une boîte pour la saisie de données, et cette fois, il est défini ci-dessous.

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

La taille de [None 2] et None signifie que vous pouvez insérer n'importe quel nombre d'échantillons, et 2 est le nombre de variables à entrer, donc ici nous le définirons sur 2 (X1, X2).

Cette fois, très simplement, la sortie de la formule suivante est équivalente à y1.

y_1 = w_1 x_1 + w_2 x_2 + w_0

Est-il possible d'estimer correctement w_1, w_2, w_0 en insérant des arbitraires (x1, x2) et y1 de manière appropriée ?? C'est un problème vraiment simple.

En fait, à ce stade, le code du premier exemple peut être utilisé tel quel, il est donc probablement très facile à implémenter et il ressemble à ce qui suit.

# 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)

Après cela, est-ce que je peux vous laisser apprendre cela?

# 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
                     })

Cela semble fonctionner une fois, mais comme c'est une bonne idée, j'aimerais savoir comment se comportent les paramètres du réseau Newral. Il semble y avoir un moyen de le lire directement, mais cela semble difficile. C'est un problème simple, j'ai donc pensé à ma propre fonction d'analyse.

L'idée est de trouver w0, w1, w2 par la méthode des moindres carrés. Considérez le réseau de neurones comme une équation d'approximation linéaire virtuelle et vérifiez ses paramètres. Tout d'abord, entrez les données

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

Et définissez les informations déduites via Newral

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

ça ira. Ce {y ^ {(nouveau)}} _k contient un nombre définitif. Puisqu'il peut y avoir un biais dans l'estimation du réseau neuronal, considérez l'équation suivante avec elle.

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

A ce moment, w_1, w_2, w_0 sont inconnus et les autres sont déterminés. Ici, pour chaque k, il est le suivant lorsqu'il est considéré comme une équation simultanée.

\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)

À ce stade, nous nous retrouvons avec un simple problème des moindres carrés. Pour la simplicité

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

Et alors,

\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)

Donc, il semble que les paramètres peuvent être obtenus. Lorsque vous créez réellement une valeur vraie, si vous définissez w_1, w_2, w_0 sur une valeur numérique et observez comment vous vous approchez de la bonne réponse ???, vous aurez l'impression de comprendre un peu le contenu du réseau neuronal. (Des rires)

Donc, je vais coller tout le code.

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, #Je mets les données d'entrée dans x
                         y_ph: y.reshape(len(y),1) #J'ai mis les bonnes données de réponse dans y
                         })
        
        # 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
                     })

Je n'ai rien écrit, mais j'ai décidé de calculer l'erreur par somme de carrés. En regardant ce résultat ... ???

[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

Puisque le vrai paramètre est w1 = 0,5, w2 = 0,5, biais (w0) = 0, il semble qu'il converge vers une bonne sensation après avoir tourné environ 30 fois.

Le réseau de neurones semblait compliqué, mais en le rendant si simple, il ressemble à un simple couplage linéaire et à un circuit équivalent. C'est peut-être un résultat évident pour l'expert, mais ce fut une grosse récolte pour moi.

Avec ce genre de ressenti, j'essaierai quelque chose d'un peu plus compliqué la prochaine fois!