Neural-Network/example.cpp at main · Eric-exe/Neural-Network · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include "neural_network\include\neural_network.h"

#include "mnist\mnist_reader.hpp"

#include <cstdio>

int main() {

    NeuralNetworkInit();

	MNIST_Reader mnist;
	mnist.readTrainingData();
	mnist.readTestData();
	mnist.randomTrainingData(500);

	// convert mnist.randomImages to inputs
	std::vector<std::vector<double>> inputs;
	for (int i = 0; i < mnist.randomImages.size(); i++) {
		std::vector<double> input;
		for (int j = 0; j < 784; j++) {
			input.push_back(mnist.randomImages[i].pixels[j]);
		}
		inputs.push_back(input);
	}

	// convert mnist.randomLabels to targetOutput
	std::vector<double> targetOutput;
	for (int i = 0; i < mnist.randomLabels.size(); i++) {
		targetOutput.push_back(mnist.randomLabels[i]);
	}

	Layer_Dense layer(784, 16);
	Activation_ReLU relu;
	Layer_Dense layer2(16, 16);
	Activation_ReLU relu2;
	Layer_Dense layer3(16, 10);
	Activation_Softmax_Loss_CategoricalCrossEntropy activation_loss;
	Accuracy accuracy;
	Optimizer_Adam optimizer(0.0005, 5e-7, 1e-7, 0.9, 0.999);

	for (int i = 0; i < 2000; i++) {
		layer.forward(inputs, true);
		relu.forward(layer.output);
		layer2.forward(relu.output);
		relu2.forward(layer2.output);
		layer3.forward(relu2.output);
		activation_loss.forward(layer3.output, targetOutput);

		accuracy.forward(activation_loss.softmax->output, targetOutput);
		std::cout << "Epoch: " << i + 1 << "|" << "Loss: " << activation_loss.loss->output << "|" << "Accuracy: " << accuracy.output << std::endl;

		// backpropagation
		activation_loss.backward(activation_loss.output, targetOutput);
		layer3.backward(activation_loss.dInputs);
		relu2.backward(layer3.dInputs);
		layer2.backward(relu2.dInputs);
		relu.backward(layer2.dInputs);
		layer.backward(relu.dInputs);

		// optimizer
		optimizer.applyDecay_pre();
		optimizer.update(&layer);
		optimizer.update(&layer2);
		optimizer.update(&layer3);
		optimizer.applyDecay_post();
	}

	mnist.randomTestData(100);

	// convert mnist.randomImages to inputs
	for (int i = 0; i < mnist.randomImages.size(); i++) {
		std::vector<double> input;
		for (int j = 0; j < 784; j++) {
			input.push_back(mnist.randomImages[i].pixels[j]);
		}
		inputs.push_back(input);
	}

	// convert mnist.randomLabels to targetOutput
	for (int i = 0; i < mnist.randomLabels.size(); i++) {
		targetOutput.push_back(mnist.randomLabels[i]);
	}

	layer.forward(inputs, true);
	relu.forward(layer.output);
	layer2.forward(relu.output);
	relu2.forward(layer2.output);
	layer3.forward(relu2.output);
	activation_loss.forward(layer3.output, targetOutput);

	accuracy.forward(activation_loss.softmax->output, targetOutput);
	std::cout << "Loss: " << activation_loss.loss->output << "|" << "Accuracy: " << accuracy.output << std::endl;

	std::getchar();
    return 0;
}