[PYTHON] Ich habe versucht, die Sündenfunktion mit Chainer zu approximieren (Re-Challenge)

Letztes Mal Ich habe versucht, die Sündenfunktion mithilfe von Chainer zu approximieren, aber es hat nicht funktioniert, also habe ich es erneut versucht, während ich verschiedene Dinge visualisierte. Zusammenfassend endete es mit einem Misserfolg. Ich verstehe immer noch nicht warum (ich habe das Gefühl, in eine lokale Lösung geraten zu sein ...). Ich wäre Ihnen sehr dankbar, wenn Sie darauf hinweisen könnten.

** Unterschiede zum letzten Mal **

• Ziel ist die Annäherung an sin (0,25x) anstelle von sin (x) Ich habe versucht, den Wert von -y auszugeben -Ausgabe des Diagramms des Verlustdurchschnitts

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:
			#Erstellen Sie Vorhersagedaten
			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()

-Tiefe Lernparameter Mini-Chargengröße 20 Anzahl der Epochen (Anzahl der Lernvorgänge) 500 Anzahl der Einheiten 1-20-20-1 Aktivierungsfunktion ReLu (normalisierte lineare Funktion) So aktualisieren Sie Adam Verlustfehlerfunktion Durchschnittliche quadratische Fehlerfunktion

Trainingsdaten

Zuerst habe ich die Zugdaten aufgezeichnet, die dieses Mal trainiert werden sollen. y=sin(0.25x)

Erstellt als Trainingsdaten um 0,5 im Bereich von 0 <x <3,14 * 40

Testdaten wurden in Intervallen von 0,5 im Bereich von 3,14 × 40,0 <x <60,0 erstellt

Verlustdurchschnitt Grafik

Ich konnte die Sündenfunktion nicht zu sehr approximieren, also habe ich sie zur Bestätigung aufgezeichnet. Der anfängliche durchschnittliche Verlust ist zu groß und scheint ab etwa Epoche 13 0 zu sein, aber er wandert tatsächlich um 0,5. Sie nimmt auf 0,5 ab, aber überhaupt nicht ab. Selbst wenn die Anzahl der Chargen und die Anzahl der Einheiten geändert wurden, stoppte der Rückgang bei etwa 0,5.

Prognosediagramm

Ich habe versucht auszugeben, welche Art von Funktion es tatsächlich wird. Epoche ist 200 Uhr

Blau ist die richtige Antwort (ursprüngliche 0,25 * sin (x) -Funktion) und Orange ist die Ausgabefunktion von Deep Learning. Nun, ich denke, dass der durchschnittliche Verlust 0,5 betragen wird. Ich denke, ich hätte die Lernrate als Lösung manipulieren sollen, als ich in eine lokale Lösung fiel, aber ich lerne noch. Was soll ich also tun?

Bitte helfen Sie jemandem (lacht)