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.

#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

Apprenez les orbites elliptiques avec Chainer
Apprenez à coloriser les images monochromes avec Chainer
Seq2Seq (1) avec chainer
Apprenez Python avec ChemTHEATER
Apprenez Zundokokiyoshi en utilisant LSTM
Pandas apprenant avec la chimioinfomatique
Utiliser tensorboard avec Chainer
Apprentissage Scikit-Learn avec la chimioinfomatique
Apprenez avec Chemo Informatics Matplotlib
Apprenez avec Chemo Informatics NumPy
DCGAN avec TF Learn
Apprenez Pendulum-v0 avec DDPG
J'ai essayé d'entraîner la fonction péché avec chainer
Essayez d'implémenter RBM avec chainer.
Apprenez de nouvelles données avec PaintsChainer
Seq2Seq (3) ~ Edition CopyNet ~ avec chainer
Utilisation du chainer avec Jetson TK1
Réseau de neurones commençant par Chainer
Implémentation du GAN conditionnel avec chainer
Génération de légende d'image avec Chainer
Implémentation de SmoothGrad avec Chainer v2
Clustering embarqué profond avec Chainer 2.0
Un peu coincé dans le chainer
Apprendre avec Causal ML Package Meta-Learner
Apprenez avec FizzBuzz Iterator, Generator, Decorator
Perceptron multicouche avec chaînette: ajustement fonctionnel
Apprenez avec les réseaux convolutifs PyTorch Graph
[TensorFlow 2] Apprendre RNN avec perte CTC
Apprenons Deep SEA avec Selene
Essayez de prédire les courses de chevaux avec Chainer
[Chainer] Apprentissage de XOR avec perceptron multicouche
Apprendre la catégorisation de documents avec la CLI spaCy
Première reconnaissance faciale d'anime avec Chainer
Exécuter l'inférence avec l'exemple de Chainer 2.0 MNIST
Utilisation de Chainer avec CentOS7 [Construction de l'environnement]
Essayez l'apprentissage de la représentation commune avec le chainer
Seq2Seq (2) ~ Attention Model edition ~ avec chainer
J'ai essayé d'apprendre l'angle du péché et du cos avec le chainer