pv021_project/NeuralNetwork.cpp at master · Kejsty/pv021_project · 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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
//
// Created by Kejsty, Katarina Kejstova on 3.11.16.
//

#include "NeuralNetwork.h"

void NeuralNetwork::renderProbs(std::vector<double> curr){
    std::vector<std::vector<double>> points;
    OutputLayer *outputLayer = dynamic_cast<OutputLayer *>(layers[layers.size()-1].get());
    double prob;
    std::vector<double> point (3);
    for(double x = curr[0] - 0.1; x <= curr[0] + 0.1; x+=0.01)
        for(double y = curr[0] - 0.1; y <= curr[0] + 0.1; y+=0.01) {
            point[0] = x;
            point[1] = y;
            point[2] = outputLayer->getProbOfInput(point);
            points.push_back(point);
        }
    imageMaker.renderProbs("", points);
}

void NeuralNetwork::run( ) {

    try {
        InputLayer *inputLayer = dynamic_cast<InputLayer *>(layers[0].get());
        OutputLayer *outputLayer = dynamic_cast<OutputLayer *>(layers[layers.size()-1].get());
        std::vector<double> curr;
        std::vector<double> last;
        int counter = 0;
        int sequence_counter = 0;
        while ( inputLayer->hasValues()) {
            counter = 0;
            while ( !inputLayer->eval()) {
                //update ImageMaker
                last = curr;
                curr = inputLayer->getValues();
                imageMaker.addLocation(curr);
                if(counter > 0) { //start after 1st sequence
                    renderProbs(curr); //render prob distribution for the next point
                }
                for ( size_t i = 1; i < layers.size(); ++i ) {
                    layers[i].get()->eval();
                }
                counter++;
            }
            if(inputLayer->isEndOfSequence()) {
                outputLayer->countSumSquaredError();
                //imageMaker.renderInput("");
                imageMaker.restart();
                sequence_counter++;
            }
            for ( size_t i = layers.size(); i > 0; --i ) {
                layers[i - 1].get()->backPropagate(inputLayer->getValues());
            }
            for ( size_t i = layers.size(); i > 0; --i ) {
                layers[i - 1].get()->clear();
            }
        }
        std::cout << "Testing started!\n";
        inputLayer->loadData("parseData\\inputExample");
        while ( inputLayer->hasValues()) {
            while ( !inputLayer->eval()) {
                for ( size_t i = 1; i < layers.size(); ++i ) {
                    layers[i].get()->eval();
                }
            }
            if(inputLayer->isEndOfSequence()){
                outputLayer->countSumSquaredError();
                // option for meanLogLoss error
                //outputLayer->countMeanLogLossError();
            }
            for ( size_t i = layers.size(); i > 0; --i ) {
                layers[i - 1].get()->clear();
            }
        }
    }catch (NeuralNetworkException &e) {
        std::cerr << e.what() << std::endl;
    }
}

NeuralNetwork::NeuralNetwork( const std::string &inputPath ) {
    try {
        layers.push_back(std::make_unique<InputLayer>(inputPath)); //0

        std::vector<Layer *> _layer1;
        _layer1.push_back(layers[0].get());
        layers.push_back(std::make_unique<HiddenLayer>(std::move(_layer1))); //1

        std::vector<Layer *> _layer2;
        _layer2.push_back(layers[0].get());
        _layer2.push_back(layers[1].get());
        layers.push_back(std::make_unique<HiddenLayer>(std::move(_layer2))); //2

        std::vector<Layer *> _layer3;
        _layer3.push_back(layers[0].get());
        _layer3.push_back(layers[2].get());
        layers.push_back(std::make_unique<HiddenLayer>(std::move(_layer3))); //3

        std::vector<Layer *> outLayer;
        outLayer.push_back(layers[1].get());
        outLayer.push_back(layers[2].get());
        outLayer.push_back(layers[3].get());
        layers.push_back(std::make_unique<OutputLayer>(std::move(outLayer), layers[0].get())); //4

        //SETTING above
        HiddenLayer *hiddenLayer1 = dynamic_cast<HiddenLayer *>(layers[1].get());
        HiddenLayer *hiddenLayer2 = dynamic_cast<HiddenLayer *>(layers[2].get());
        HiddenLayer *hiddenLayer3 = dynamic_cast<HiddenLayer *>(layers[3].get());

        hiddenLayer3->setAbove(layers[4].get()); // outputL
        hiddenLayer3->setAbove(layers[3].get()); // me

        hiddenLayer2->setAbove(layers[4].get()); // outputL
        hiddenLayer2->setAbove(layers[3].get()); // above Hiiden L
        hiddenLayer2->setAbove(layers[2].get()); // me

        hiddenLayer1->setAbove(layers[4].get()); // outputL
        hiddenLayer1->setAbove(layers[2].get()); // above Hiiden L
        hiddenLayer1->setAbove(layers[1].get()); // me
    }catch (NeuralNetworkException &e) {
        std::cerr << e.what() << std::endl;
    }
}