[PYTHON] J'ai essayé d'approcher la fonction sin en utilisant chainer (re-challenge)
La dernière fois J'ai essayé d'approcher la fonction sin en utilisant chainer, mais cela n'a pas fonctionné, j'ai donc essayé à nouveau en visualisant diverses choses. En conclusion, cela s'est soldé par un échec. Je ne sais toujours pas pourquoi (j'ai l'impression d'être tombé dans une solution locale ...). Je vous serais très reconnaissant de bien vouloir le signaler.
** Différences par rapport à la dernière fois ** -Vise à approximer sin (0,25x) au lieu de sin (x) J'ai essayé de sortir la valeur de -y -Output le graphique de la moyenne des pertes
sin_NN.py
import numpy as np
import six
import chainer
from chainer import computational_graph as c
from chainer import cuda
import chainer.functions as F
from chainer import optimizers
import matplotlib.pyplot as plt
import csv
def make_dateset():
x_train = np.arange(0,3.14*40.0,0.5)
y_train = np.sin(0.25 * x_train).astype(np.float32)
f = open('sin_train.csv','ab')
csvWriter = csv.writer(f)
csvWriter.writerow(x_train)
csvWriter.writerow(y_train)
f.close()
x_test = np.arange(3.14*40.0,3.14 * 60.0,0.5)
y_test = np.sin(0.25 * x_test).astype(np.float32)
return x_train.astype(np.float32),y_train.astype(np.float32),x_test.astype(np.float32),y_test.astype(np.float32)
def forward(x_data,y_data,train = True,pred_flag = False):
if pred_flag:
x = chainer.Variable(x_data)
train = False
else:
x,t = chainer.Variable(x_data),chainer.Variable(y_data)
h1 = F.dropout(F.relu(model.l1(x)), train=train)
h2 = F.dropout(F.relu(model.l2(h1)), train=train)
h3 = F.dropout(F.relu(model.l3(h2)), train=train)
y = model.l4(h3)
if pred_flag:
return y
else:
return F.mean_squared_error(y,t)
if __name__ == "__main__":
x_train,y_train,x_test,y_test = make_dateset()
x_train = x_train.reshape(len(x_train),1)
y_train = y_train.reshape(len(y_train),1)
x_test = x_test.reshape(len(x_test),1)
y_test = y_test.reshape(len(y_test),1)
xp = np
batchsize = 20
N = len(x_train)
N_test = len(x_test)
n_epoch = 500
n_units = 10
model = chainer.FunctionSet(l1=F.Linear(1, n_units),
l2=F.Linear(n_units, n_units),
l3=F.Linear(n_units, n_units),
l4=F.Linear(n_units, 1))
optimizer = optimizers.Adam()
optimizer.setup(model.collect_parameters())
loss_means = []
for epoch in six.moves.range(1, n_epoch + 1):
print('epoch', epoch)
#train
perm = np.random.permutation(N)
sum_loss = 0
sum_accuracy = 0
for i in six.moves.range(0, N, batchsize):
x_batch = xp.asarray(x_train[perm[i:i + batchsize]])
y_batch = xp.asarray(y_train[perm[i:i + batchsize]])
optimizer.zero_grads()
loss = forward(x_batch, y_batch)
loss.backward()
optimizer.update()
sum_loss += float(cuda.to_cpu(loss.data)) * len(y_batch)
print "train mean loss = ",sum_loss/N
#evaluation
sum_loss = 0
sum_accuracy = 0
for i in six.moves.range(0, N_test, batchsize):
x_batch = xp.asarray(x_test[i:i+batchsize])
y_batch = xp.asarray(y_test[i:i+batchsize])
loss = forward(x_batch, y_batch, train=False)
sum_loss += float(cuda.to_cpu(loss.data)) * len(y_batch)
###################################################
if epoch == 200:
#Créer des données de prédiction
x_pre = np.arange(3.14*80.0,3.14*120.0,0.5)
x_pre = x_pre.astype(np.float32)
y_pre = np.sin(0.25 * x_pre).astype(np.float32)
y_pre = y_pre.reshape(1,len(y_pre))
answer = []
#predict
for g in range(0,len(x_pre)-1):
xx = np.asarray([[x_pre[g]]])
y1 = forward(x_data = xx,y_data = None,train = False,pred_flag=True)
answer.append(y1.data[0][0])
f = open('sin_pre.csv','ab')
csvWriter = csv.writer(f)
csvWriter.writerow(x_pre)
csvWriter.writerow(y_pre[0])
csvWriter.writerow(answer)
f.close()
####################
print "test mean loss = ",sum_loss/N_test
loss_means.append(sum_loss/N_test)
f = open('loss_means.csv','ab')
csvWriter = csv.writer(f)
csvWriter.writerow(loss_means)
f.close()
-Paramètres d'apprentissage profond Mini taille de lot 20 Nombre d'époques (nombre d'apprentissage) 500 Nombre d'unités 1-20-20-1 Fonction d'activation ReLu (fonction linéaire normalisée) Comment mettre à jour Adam Fonction d'erreur de perte Fonction d'erreur quadratique moyenne
Données d'entraînement
Tout d'abord, j'ai tracé les données du train à entraîner cette fois.
y=sin(0.25x)
Créé en tant que données d'entraînement par 0,5 dans la plage 0 <x <3,14 * 40
Les données de test ont été créées à 0,5 intervalles dans la plage de 3,14 * 40,0 <x <60,0
Graphique de la moyenne des pertes
Je ne pouvais pas trop approcher la fonction sin, alors je l'ai tracée pour confirmation. La perte moyenne initiale est trop importante et semble être de 0 à partir de l'époque 13 environ, mais elle erre en fait autour de 0,5. Il diminue à 0,5, mais ne diminue pas du tout. Même si le nombre de lots et le nombre d'unités ont été modifiés, la diminution s'est arrêtée autour de 0,5.
Graphique des prévisions
J'ai essayé de sortir le type de fonction qu'il devenait réellement. l'époque est à 200 heures
Le bleu est la bonne réponse (fonction d'origine 0,25 * sin (x)) et l'orange est la fonction de sortie du Deep Learning. Eh bien, je pense que la perte moyenne sera de 0,5. Je pense que j'aurais dû altérer le taux d'apprentissage comme solution lorsque je suis tombé dans une solution locale, mais j'étudie toujours, alors que dois-je faire?
S'il vous plaît, aidez quelqu'un (rires)
Recommended Posts