[PYTHON] Apprenez les orbites elliptiques avec Chainer
En utilisant le chainer, apprenez l'orbite elliptique avec le Feedforward Neural Network. Le test se fait en boucle ouverte.
Je vais résoudre ce problème tout en expliquant comment utiliser le chainer.
Problèmes et approches
[problème] Apprenez les orbites elliptiques de x = 0.8cos (θ) et y = 0.8sin (θ).
[approche] x(θn)＝(0.8cos(θn),0.8sin(θn)), (0<=θn<=2π) Concevez un FNN qui prédit x (θn + 1) à partir de x (θn). Ensuite, utilisez ce FNN pour apprendre à utiliser les données d'entraînement, puis testez et confirmez les résultats à l'aide des données de test.
Création de données et paramétrage des variables
Données d'entraînement et données de test
Spécifiez n'importe quel point sur l'ellipse.
[Données d'entraînement] xtrain (θn) = (0.8cos (θn), 0.8sin (θn)), θn = 2πn / 20 (0 <= n <= 20, n est un entier naturel) ça ira. Écrivez comme suit.
a=np.linspace(0,20,sample_no).reshape(sample_no,1)
xtrain=np.zeros(input_no*sample_no).reshape(sample_no,input_no).astype(np.float32)
xtrain[:,0]=[0.8*np.cos(2.0*np.pi*i/20) for i in a]
xtrain[:,1]=[0.8*np.sin(2.0*np.pi*i/20) for i in a]
[données de test] xtest (θn) = (0.8cos (θn), 0.8sin (θn)), θn = 2πn / 27 (0 <= n <= 27, n est un entier naturel) ça ira. De même, écrivez comme suit.
a=np.linspace(0,27,sample_no).reshape(sample_no,1)
xtest=np.zeros(input_no*sample_no).reshape(sample_no,input_no).astype(np.float32)
xtest[:,0]=[0.8*np.cos(2.0*np.pi*i/27) for i in a]
xtest[:,1]=[0.8*np.sin(2.0*np.pi*i/27) for i in a]
variable
Réglez comme suit. Nombre de données enseignant: sample_no Nombre d'apprentissage: époque Nombre de couches: Couche d'entrée: input_no = 2 (fixe) Couche intermédiaire: hidden_no Couche de sortie: output_no = 2 (fixe) Taille du lot: bs
Structure du modèle d'apprentissage par chainer
Préparer une connexion (Link)
Enregistrez un lien appelé Linéaire avec les noms l1 et l2.
class FNN(Chain):
def __init__(self): #Préparez une connexion
super(FNN,self).__init__(
l1=L.Linear(input_no,hidden_no),
l2=L.Linear(hidden_no,output_no),
De plus, il convient de noter l1=L.Linear(input_no,hidden_no), l2=L.Linear(hidden_no,output_no), Est self.add_link("l1",F.Linear(input_no,hidden_no)), self.add_link("l2",F.Linear(hidden_no,output_no)), C'est la même chose que l'écriture.
calcul à terme
Le lien enregistré est appelé en tant que fonction. L'argument semble être une classe variable en principe.
- Chainer.variable (data): Créez une variable de chaînage numérique appelée data. La fonction d'activation est appelée depuis chainer.functions (F). (Cette fois, c'est tanh.)
#class FNN
def fwd(self,x):
h1=F.tanh(self.l1(x))
h2=F.tanh(self.l2(h1))
return h2
def get_predata(self,x):
return self.fwd(Variable(x.astype(np.float32).reshape(sample_no,input_no))).data
Fonction de perte
Appelé depuis chainer.functions. Cette fois, nous utiliserons l'erreur quadratique moyenne.
#class FNN
def __call__(self,x,y): #Fonction de perte
return F.mean_squared_error(self.fwd(x),y)
optimisation
Créez un optimiseur et définissez-le avec le modèle FNN. Il existe différents types tels que SGD, Adam et RMS Drop.
model=FNN()
optimizer=optimizers.SGD()
optimizer.setup(model)
Entraînement
Entraînez l'ensemble de données précédent (Xtrain_n + 1) comme réponse correcte pour l'ensemble de données actuel (Xtrain_n). Initialisation, rétropropagation et mise à jour du dégradé optimizer.zero_grads() loss.backward() optimizer.update() Répéter.
for i in range(epoch):
for j in range(sample_no): #Mettez un en avant
if (j+1<sample_no):
ytrain[j]=np.array(xtrain[j+1])
else:
ytrain[j]=np.array(xtrain[0])
model.zerograds()
loss=model(xtrain,ytrain)
loss.backward()
optimizer.update()
tester
Comme il est effectué en boucle ouverte, il lit les données de test à chaque fois et prédit le point suivant. Les données de test sont calculées par FeedForward et vous sont envoyées, alors écrivez simplement comme suit.
yout=model.get_predata(xtest)
résultats de test
Les données de l'enseignant (ellipse cible) sont dessinées en bleu et les résultats du test sont dessinés en rouge.
100 temps d'apprentissage: toujours désynchronisés
5000 leçons: ça se rapproche d'une ellipse
Nombre d'apprentissage 5000000 fois: réponse presque correcte
Code complet
ellipse.py
#-*- coding:utf-8 -*-
import numpy as np
import chainer
from chainer import cuda,Function,gradient_check,Variable,optimizers,serializers,utils
from chainer import Link,Chain,ChainList
import chainer.functions as F
import chainer.links as L
from sklearn import datasets
import matplotlib.pyplot as plt
#Nombre de données sur les enseignants
sample_no=100
#Nombre d'apprentissage
epoch=500000
#Nombre de couches
input_no=2
hidden_no=2
output_no=2
#Création de données enseignants
a=np.linspace(0,20,sample_no).reshape(sample_no,1)
xtrain=np.zeros(input_no*sample_no).reshape(sample_no,input_no).astype(np.float32)
xtrain[:,0]=[0.8*np.cos(2.0*np.pi*i/20) for i in a]
xtrain[:,1]=[0.8*np.sin(2.0*np.pi*i/20) for i in a]
#Construire un modèle
class FNN(Chain):
def __init__(self): #Préparez une connexion
super(FNN,self).__init__(
l1=L.Linear(input_no,hidden_no),
l2=L.Linear(hidden_no,output_no),
)
def __call__(self,x,y): #Fonction de perte
return F.mean_squared_error(self.fwd(x),y)
def fwd(self,x):
h1=F.tanh(self.l1(x))
h2=F.tanh(self.l2(h1))
return h2
def get_predata(self,x):
return self.fwd(Variable(x.astype(np.float32).reshape(sample_no,input_no))).data
#Méthode d'optimisation
model=FNN()
optimizer=optimizers.SGD()
optimizer.setup(model)
#Stocke la valeur de réponse correcte pour la formation
ytrain=np.zeros(input_no*sample_no).reshape(sample_no,input_no).astype(np.float32)
#Taille du lot
bs=25
#Entraînement
for i in range(epoch):
for j in range(sample_no): #Mettez un en avant
if (j+1<sample_no):
ytrain[j]=np.array(xtrain[j+1])
else:
ytrain[j]=np.array(xtrain[0])
model.zerograds()
loss=model(xtrain,ytrain)
loss.backward()
optimizer.update()
#tester(openloop)
a=np.linspace(0,27,sample_no).reshape(sample_no,1)
xtest=np.zeros(input_no*sample_no).reshape(sample_no,input_no).astype(np.float32)
xtest[:,0]=[0.8*np.cos(2.0*np.pi*i/27) for i in a]
xtest[:,1]=[0.8*np.sin(2.0*np.pi*i/27) for i in a]
yout=model.get_predata(xtest)
print yout
#dessin
plt.plot(yout[:,0],yout[:,1],"r",label="training data") #Dessiner les résultats d'apprentissage en rouge
plt.plot(xtrain[:,0],xtrain[:,1],"b",label="teaching data") #Dessinez les données des enseignants en bleu
plt.show()
Recommended Posts