[Deep Learning von Grund auf neu] in Java 3. Neuronales Netzwerk

Einführung

[Deep Learning von Grund auf in Java] 2. NumPy gibt es nicht. ](Https://qiita.com/xaatw0/items/011168383246d4e95145) Es ist eine Fortsetzung von. Ich trat schließlich in das neuronale Netzwerk ein und es wurde mehr wie tiefes Lernen.

Aktivierungsfunktion

Erstens ist es eine übliche Methode, die die angegebene Funktion auf alle Elemente des zweidimensionalen Arrays anwendet.

ArrayUtil.java

public double[][] apply(double[][] x, DoubleUnaryOperator op){

	validate(x);
	double[][] result = new double[x.length][x[0].length];
	for (int i = 0; i < result.length; i++){
		for (int j = 0; j < result[0].length; j++){
			result[i][j] = op.applyAsDouble(x[i][j]);
		}
	}

	return result;
}

Es ist P48 "3.2.4 Implementierung der Sigmoidfunktion" des Buches. Math.exp, was gut für Java war.

ArrayUtil.java

private DoubleUnaryOperator sigmoid = p ->1/(1+ Math.exp(-1 * p));
public double[][] sigmoid(double[][] x){
	return apply(x, sigmoid);
}

Als nächstes P52 "3.2.7 ReLU-Funktion".

ArrayUtil.java

private DoubleUnaryOperator relu = p -> p < 0 ? 0 : p;
public double[][] relu(double[][] x){
	return apply(x, relu);
}

neurales Netzwerk

P65 "3.4.3 Implementierungszusammenfassung"

ArrayUtilTest.java

public void newralnetwork(){
	// init_network()
	double[][] W1 = {{0.1, 0.3, 0.5},{0.2, 0.4, 0.6}};
	double[]   b1 = {0.1, 0.2, 0.3};
	double[][] W2 = {{0.1,0.4},{0.2,0.5},{0.3,0.6}};
	double[]   b2 = {0.1, 0.2};
	double[][] W3 = {{0.1,0.3},{0.2,0.4}};
	double[]   b3 = {0.1, 0.2};

	// x - np.array([1.0, 0.5])
	double[][] x = {{1.0, 0.5}};

	// a1 = np.dot(x,W1)+b1
	double[][] a1 = target.plus( target.multi(x, W1), b1);

	// z1 = sigmoid(a1)
	double[][] z1 = target.sigmoid(a1);

	assertThat(z1[0][0], is(closeTo(0.57444252, 0.00001)));
	assertThat(z1[0][1], is(closeTo(0.66818777, 0.00001)));
	assertThat(z1[0][2], is(closeTo(0.75026011, 0.00001)));

	// a2 = np.dot(z1,W2)+b2
	double[][] a2 = target.plus( target.multi(z1, W2), b2);

	// z2 = sigmoid(a2)
	double[][] z2 = target.sigmoid(a2);
	assertThat(z2[0][0], is(closeTo(0.62624937, 0.00001)));
	assertThat(z2[0][1], is(closeTo(0.7710107, 0.00001)));

	// a3 = np.dot(z2,W3)+b3
	double[][] a3 = target.plus( target.multi(z2, W3), b3);

	// print(y) #[0.31682708,0.69627909]
	assertThat(a3[0][0], is(closeTo(0.31682708, 0.00001)));
	assertThat(a3[0][1], is(closeTo(0.69627909, 0.00001)));
}

Design der Ausgabeschicht

Implementierung der Softmax-Funktion aus P69 "3.5.2 Vorsichtsmaßnahmen zur Implementierung der Softmax-Funktion".

ArrayUtil.java

public double[] softmax(double[] x){
	double maxValue = Arrays.stream(x).max().getAsDouble();
	double[] value = Arrays.stream(x).map(y-> Math.exp(y - maxValue)).toArray();
	double total = Arrays.stream(value).sum();
	return Arrays.stream(value).map(p -> p/total).toArray();
}

public double[][] softmax(double[][] x){
	double[][] result = new double[x.length][];
	for (int i = 0; i < result.length; i++){
		result[i] = softmax(x[i]);
	}
	return result;
}

ArrayUtilTest.java

ArrayUtil target = new ArrayUtil();

@Test
public void softmax(){
	double[] x = {1010, 1000, 990};
	double[] expected = {9.99954600e-01, 4.53978686e-05, 2.06106005e-09};

	double[] result = target.softmax(x);
	assertThat(result[0], is(closeTo(expected[0], 0.00001)));
	assertThat(result[1], is(closeTo(expected[1], 0.00001)));
	assertThat(result[2], is(closeTo(expected[2], 0.00001)));

	assertThat(Arrays.stream(result).sum(), is(closeTo(1, 0.00001)));
}

abschließend

Vorerst konnte ich ein neuronales Netzwerk und eine Softmax-Funktion implementieren. Von hier an können Sie es selbst verstehen, aber Sie werden nicht verstehen können, was als Ganzes vor sich geht. Die Ausgabe entspricht dem Buch, Sie sollten also keinen Fehler machen.