Fonction sinueuse approximative avec TensorFlow

Je vais vous expliquer un programme qui se rapproche de la fonction sin tout en étudiant comment utiliser TensorFlow.

Modèle d'apprentissage

Définition des paramètres

À propos de X (valeur d'entrée) et t (données de l'enseignant). Enregistrer les données de l'ensemble d'entraînement dans l'espace réservé Par exemple, [Aucun, 5] représente une matrice de [arbitraire x 5]. t est réglé sur [Aucun, 1] afin que le nombre de données puisse être pris arbitrairement.

Environ w (poids). Puisqu'elle correspond à la variable à optimiser, elle est définie comme une instance de la classe tf.Variable. Créez une matrice 5x1 avec une valeur initiale de 0.

Avec ceux-ci, un réseau de couche d'entrée 1, de couche intermédiaire 5 et de couche de sortie 1 est créé.

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

une formule

L'expression de y = Xw est exprimée comme suit.

y=tf.matmul(x,w)

tf.matmul est une fonction qui multiplie la matrice et utilise l'espace réservé x et la variable w définis précédemment. Aucune valeur spécifique n'a encore été saisie et y n'a pas été déterminé.

Fonction d'erreur

La différence entre les données de l'enseignant t et la sortie y est la somme des carrés. Nous apprendrons à minimiser cette erreur carrée. Sélectionnez également l'algorithme d'optimisation à ce stade.

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

Exécution de la formation

Préparer une session

Nous calculerons les variables correspondant à Variable en utilisant la "session" qui est l'environnement d'exécution de l'algorithme d'apprentissage. Tout d'abord, préparez une nouvelle session et initialisez Variable.

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

Affectation de l'ensemble de données de formation

Remplacez les données de l'ensemble d'apprentissage par l'espace réservé. train_t correspond aux données réelles.

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

Mise en œuvre de l'optimisation

Exécutez l'algorithme d'entraînement défini train_step pour corriger les poids. À ce stade, une valeur spécifique est définie dans Placeholder avec feed_dict. Vous pouvez également évaluer la perte dans une session et récupérer sa valeur actuelle, telle que loss_val. Ensuite, la valeur du paramètre au moment où l'apprentissage est arrêté (après avoir quitté la boucle for) est sortie.

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

tester

La courbe du résultat du test est générée par la formule suivante. 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

résultat

Lorsque la couche intermédiaire est de 5 couches et que le nombre d'apprentissage est de 10000 fois Bien que cela s'écarte de l'intrigue, je pense que cela peut être approximativement approximatif.

Essayez de changer le nombre de couches intermédiaires ... Couche intermédiaire 6 couches: Elle a plus décalé.

Couche intermédiaire 4 couches: Il est plus proche de 5 couches.

Il est également important de spécifier le nombre approprié de couches intermédiaires (hyper paramètres). ..

Code complet

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