Mauvais resultats

#include <iostream>
#include "E:/NeuralNetwork/NeuralNetwork.hpp"

int main(void) {

    // Topologie du réseau
    NeuralNetwork::Topology topologie{ 4, 4, 4 , 8 , 4 };

    NeuralNetwork Brain{ topologie };

    // Dataset d'entrée
    std::vector<NeuralNetwork::DataSet> dataset_;

    NeuralNetwork::DataSet datas_p1{0,0,
                                    0,0}; // bloc plein

    NeuralNetwork::DataSet datas_p2{1,1,
                                    1,1}; // bloc plein

    NeuralNetwork::DataSet datas_v1{1,0,
                                    1,0}; // Vertical

    NeuralNetwork::DataSet datas_v2{0,1,
                                    0,1}; // Vertical

    NeuralNetwork::DataSet datas_h1{1,1,
                                    0,0}; // Horizontal

    NeuralNetwork::DataSet datas_h2{0,0,
                                    1,1}; // Horizontal

    NeuralNetwork::DataSet datas_d1{1,0,
                                    0,1}; // Diagonal

    NeuralNetwork::DataSet datas_d2{0,1,
                                    1,0}; // Diagonal

    dataset_.push_back(datas_p1);
    dataset_.push_back(datas_p2);
    dataset_.push_back(datas_v1);
    dataset_.push_back(datas_v2);
    dataset_.push_back(datas_h1);
    dataset_.push_back(datas_h2);
    dataset_.push_back(datas_d1);
    dataset_.push_back(datas_d2);

    std::vector<NeuralNetwork::DataSet> expected_output{ 
        { 1,0,0,0 },
        { 1,0,0,0 },
        { 0,1,0,0 },
        { 0,1,0,0 },
        { 0,0,1,0 },
        { 0,0,1,0 },
        { 0,0,0,1 },
        { 0,0,0,1 },
    };

    for (size_t i = 0; i < 500 ; i++) {
        for (size_t d = 0; d < dataset_.size(); d++) {
            Brain.feedForward(dataset_[d]);
            Brain.backPropagate(expected_output[d]);
        }
    }

    NeuralNetwork::ResultSet results;

    Brain.feedForward(datas_d1);
    Brain.getResults(results);

    for (auto const & r : results) {
        std::cout << r << std::endl;
    }

    std::cin.get();

    return 0;
}

#ifndef NEURALNETWORK_HPP
#define NEURALNETWORK_HPP

#include <vector>
#include <utility>
#include <random>
#include <assert.h>

class NeuralNetwork{

    public:

        class Node;

        // definition de quelques types
        using DataSet = std::vector<double>;
        using ResultSet = std::vector<double>;
        using Topology = std::vector<size_t>; // Nombre de couches ( layer ) et de neurones par couche
        using Layer = std::vector<Node>; // Couche de Node ( neurone )

        // Defini une connection jusqu'a une neurone de la couche suivante par un poid
        struct Connection{

            // Constructeur par defaut
            Connection() :
                Connection{0.0}
            {}

            // Constructeur
            Connection(double w) :
                weigth_{w},
                delta_weigth_{0.0}
            {}

            double weigth_; // Poid de la connection
            double delta_weigth_;
        };

        // Defini une neurone
        class Node{

            public:
                double eta_; //training rate
                double alpha_;

                // Constructeur
                Node(size_t output_size, size_t num){
                    // output_size = nombre de connection a la couche suivante
                    for(size_t i = 0; i < output_size; i++){
                        // Pour chaque neurone de la couche suivante , on ajoute une connection a la neurone
                        connections_.push_back(Connection(randomWeigth()));
                    }

                    nodenum_ = num;
                    eta_ = 0.15;
                    alpha_ = 0.5;
                };

                void feedForward(const NeuralNetwork::Layer & prev_layer) {

                    double sum = 0.0;

                    for (size_t n = 0; n < prev_layer.size(); n++) {
                        sum += (prev_layer[n].getOutput() * prev_layer[n].connections_[nodenum_].weigth_);
                    }

                    output_ = Node::activationFunction(sum);
                }

                void setOutput(double value) { output_ = value; }
                double getOutput() const { return output_; } 

                void calculateGradients(double value) {
                    double delta = value - output_;
                    gradient_ = delta * Node::activationFunction(output_);
                };

                double sumDOW(Layer const & layer) {

                    double sum = 0.0;
                    for (size_t n = 0; n < layer.size() - 1; n++) {
                        sum += connections_[n].weigth_;
                    }

                    return sum;
                }

                void updateWeigths(Layer &prev_layer) {

                    for (size_t n = 0; n < prev_layer.size(); n++) {

                        Node & node = prev_layer[n];

                        double oldDelta = node.connections_[nodenum_].delta_weigth_;
                        double newDelta = (eta_ * node.getOutput() * gradient_) + (alpha_ * oldDelta);

                        node.connections_[nodenum_].delta_weigth_ = newDelta;
                        node.connections_[nodenum_].weigth_ = newDelta;
                    }
                }

                void calculateHiddenGradients(Layer const & layer) {
                    double dow = sumDOW(layer);
                    gradient_ = dow * Node::activationFunction(output_);
                }

            private:

                double output_; // Valeur de sorti de la neurone
                size_t nodenum_;
                std::vector<Connection> connections_;
                double gradient_;

                static double randomWeigth() { return rand() / double(RAND_MAX); }

                static double activationFunction(double sum) {
                    return tanh(sum);
                }

        }; // Une neurone

        // Constructeur du réseau
        NeuralNetwork(Topology const &topo){

            for(size_t j = 0; j < topo.size(); j++){

                // Nombre de connections pour les neurones de cette couche
                // si c'est la derniere couche il y a 0 connections
                // sinon le nombre de connections = le nombre de neurones sur la prochaine couche
                auto conn_size = ( j == topo.size() - 1 ? 0 : topo[j+1]);

                // On ajoute une couche
                layers_.push_back(Layer());

                auto & last_layer_added = layers_.back();

                auto layer_size = topo[j];

                //Pour chaque nombre de neurone dans la couche
                for(size_t i = 0; i <= layer_size ; i++){
                    // On ajoute une neurone avec le nombre de connections necessaire
                    last_layer_added.push_back(Node(conn_size,i));
                }

                last_layer_added.back().setOutput(1.0);
            }
        };

        // FONCTION FEEDFORWARD
        void feedForward(DataSet const & inputs){

            // Nombre de données == nombre entré premiere couche
            assert(inputs.size() == layers_[0].size() - 1);

            // Entrée des données dans la premiere couche
            for (size_t i = 0; i < inputs.size(); i++) {
                layers_[0][i].setOutput(inputs[i]);
            }

            // Feed des couches cachées
            for (size_t layer_num = 1; layer_num < layers_.size() - 1; layer_num++) {

                // Récuperation de la couche précédente
                Layer &prev_layer = layers_[layer_num - 1];

                // Feed forward des données 
                for (size_t n = 0; n < layers_[layer_num].size() - 1; n++) {
                    layers_[layer_num][n].feedForward(prev_layer);
                }
            }
        }

        // FONCTION BACKPROPAGATE
        void backPropagate(DataSet const & inputs){

            // derniere couche = couche de sortie
            Layer &outputLayer = layers_.back();

            error_ = 0.0;

            for (size_t n = 0; n < outputLayer.size() - 1; n++) {
                double delta = inputs[n] - outputLayer[n].getOutput();
                error_ += delta*delta;
            }

            error_ /= outputLayer.size() - 1;
            error_ = sqrt(error_);

            recentAverageError_ = (recentAverageError_ * error_) / (1.0);

            for (size_t n = 0; n < outputLayer.size() - 1; n++) {
                outputLayer[n].calculateGradients(inputs[n]);
            }

            for (size_t layer = layers_.size() - 2; layer = 0; layer++) {

                Layer & hiddenLayer = layers_[layer];
                Layer & nextLayer = layers_[layer + 1];

                for (size_t n = 0; n < hiddenLayer.size()-1; n++) {
                    hiddenLayer[n].calculateHiddenGradients(nextLayer);
                }
            }

            for (size_t layer_num = layers_.size() - 1; layer_num > 0; layer_num--) {
                Layer &layer = layers_[layer_num];
                Layer &prev_layer = layers_[layer_num - 1];

                for (size_t n = 0; n < layer.size()-1; n++) {
                    layer[n].updateWeigths(prev_layer);
                }

            }
        }
        void getResults(ResultSet & results) const {
            results.clear();

            for (size_t n = 0; n < layers_.back().size() - 1; n++) {
                results.push_back(layers_.back()[n].getOutput());
            }
        }

    private:
        std::vector<Layer> layers_; // layers_[LayerNum][NodeNum]
        double error_;
        double recentAverageError_;
};

#endif

`

-9.2559e+61
-9.2559e+61
-9.2559e+61
-9.2559e+61