Updating Network functions

annclasses.cpp

@@ -3,6 +3,7 @@
 #include <cmath>
 #include <forward_list>
 #include <algorithm>
+#include <numeric>
 #include "annclasses.h"
 
 using namespace std;
@@ -114,6 +115,8 @@ Network::Network(int n_layers, int n_neurons)
     h_activ = RELU;
     //o_activ = SIGMOID;
     o_activ = LINEAR;
+
+    neurons_number = n_layers*n_neurons;
 }
 
 Network::Network(const std::vector<int> &n_neurons, Activ h_activ, Activ o_activ)
@@ -138,15 +141,61 @@ Network::Network(const std::vector<int> &n_neurons, Activ h_activ, Activ o_activ
     }
     h_activ = h_activ;
     o_activ = o_activ;
+
+    neurons_number = accumulate(n_neurons.begin(), n_neurons.end(), 0);
 }
 
-bool Network::train(const std::vector<float> &input, const std::vector<float> &target, float learning_rate, int n_episodes)
+int Network::get_neurons_number()
 {
-    for(int episode=1;episode<=n_episodes;episode++)
+    return neurons_number;
+}
+
+bool Network::train(const vector<vector<float>> &inputs, const vector<vector<float>> &targets, float learning_rate, int n_episodes, int batch_size)
+{
+    if(inputs.size() == targets.size())
+    {
+        vector<vector<float>> all_activated_outputs(get_neurons_number());
+        vector<vector<float>> all_derrors(get_neurons_number()-inputs.at(0).size());
+        bool is_constructed = false;
+        for(int episode=1 ; episode<=n_episodes ; episode++)
+        {
+            for(int index(0) ; index<inputs.size() ; index++)//batch_size not yet used
+            {
+                forward(inputs.at(index), targets.at(index));
+                set_errors(targets.at(index));
+
+                int layer_counter = 0;
+                int neurons_counter1 = 0;
+                int neurons_counter2 = 0;
+                for(list<forward_list<Neuron>>::iterator current_layer(layers.begin()) ; current_layer!=layers.end() ; ++current_layer)
+                {
+                    layer_counter++;
+                    if(layer_counter==1)
+                    {
+                        for(forward_list<Neuron>::iterator current_neuron(current_layer->begin()) ; current_neuron!=current_layer->end() ; ++current_neuron)
+                        {
+                            all_activated_outputs.at(neurons_counter1).push_back( current_neuron->get_activated_output() );
+                            neurons_counter1++;
+                        }
+                    }else
+                    {
+                        for(forward_list<Neuron>::iterator current_neuron(current_layer->begin()) ; current_neuron!=current_layer->end() ; ++current_neuron)
+                        {
+                            all_activated_outputs.at(neurons_counter1).push_back( current_neuron->get_activated_output() );
+                            neurons_counter1++;
+
+                            all_derrors.at(neurons_counter2).push_back( current_neuron->get_derror() );
+                            neurons_counter2++;
+                        }
+                    }
+                }
+            }
+            backward(learning_rate);
+        }
+    }else
     {
-        forward(input, target);
-        set_errors(target);
-        backward(learning_rate);
+        cerr << "Inputs and targets vectors have different size" << endl;
+        exit(-1);
     }
     return true;
 }
@@ -252,48 +301,53 @@ bool Network::backward(float learning_rate)
 
 bool neuron_cmp(Neuron a, Neuron b){return a.get_activated_output()<b.get_activated_output();}
 
-float Network::predict(const std::vector<float> &input, bool as_raw)
+vector<float> Network::predict(const vector<vector<float>> &inputs, bool as_raw)
 {
-    int layer_counter = 0;
-    for(list<forward_list<Neuron>>::iterator current_layer(layers.begin()) ; current_layer!=layers.end() ; ++current_layer)
-    {//inside current layer
-        layer_counter++;
-        if(layer_counter==1)
-        {
-            int i=0;
-            for(forward_list<Neuron>::iterator current_neuron(current_layer->begin()) ; current_neuron!=current_layer->end() ; ++current_neuron)
-            {//inside current neuron
-                current_neuron->set_activated_output( input.at(i) );
-                i++;
+    vector<float> results;
+    for(auto input : inputs)
+    {
+        int layer_counter = 0;
+        for(list<forward_list<Neuron>>::iterator current_layer(layers.begin()) ; current_layer!=layers.end() ; ++current_layer)
+        {//inside current layer
+            layer_counter++;
+            if(layer_counter==1)
+            {
+                int i=0;
+                for(forward_list<Neuron>::iterator current_neuron(current_layer->begin()) ; current_neuron!=current_layer->end() ; ++current_neuron)
+                {//inside current neuron
+                    current_neuron->set_activated_output( input.at(i) );
+                    i++;
+                }
+            }else if(layer_counter==layers.size())
+            {
+                list<forward_list<Neuron>>::iterator temp = current_layer;
+                temp--; //previous layer
+                for(forward_list<Neuron>::iterator current_neuron(current_layer->begin()) ; current_neuron!=current_layer->end() ; ++current_neuron)
+                {//inside current neuron
+                    forward_list<Neuron>::iterator prev_layer_it(temp->begin());
+                    current_neuron->activate(prev_layer_it, o_activ);
+                }
+            }else
+            {
+                list<forward_list<Neuron>>::iterator temp_prev_layer = current_layer; //temp_prev_layer set at current layer
+                temp_prev_layer--; //temp_prev_layer set now at previous layer
+                for(forward_list<Neuron>::iterator current_neuron(current_layer->begin()) ; current_neuron!=current_layer->end() ; ++current_neuron)
+                {//inside current neuron
+                    forward_list<Neuron>::iterator prev_layer_it(temp_prev_layer->begin());
+                    current_neuron->activate(prev_layer_it, h_activ);
+                }
             }
-        }else if(layer_counter==layers.size())
+        }
+        list<forward_list<Neuron>>::iterator output_layer = layers.end(); output_layer--;
+        if(as_raw)
         {
-            list<forward_list<Neuron>>::iterator temp = current_layer;
-            temp--; //previous layer
-            for(forward_list<Neuron>::iterator current_neuron(current_layer->begin()) ; current_neuron!=current_layer->end() ; ++current_neuron)
-            {//inside current neuron
-                forward_list<Neuron>::iterator prev_layer_it(temp->begin());
-                current_neuron->activate(prev_layer_it, o_activ);
-            }
+            results.push_back( max_element(output_layer->begin(), output_layer->end(), neuron_cmp)->get_activated_output() );
         }else
         {
-            list<forward_list<Neuron>>::iterator temp_prev_layer = current_layer; //temp_prev_layer set at current layer
-            temp_prev_layer--; ////temp_prev_layer set now at previous layer
-            for(forward_list<Neuron>::iterator current_neuron(current_layer->begin()) ; current_neuron!=current_layer->end() ; ++current_neuron)
-            {//inside current neuron
-                forward_list<Neuron>::iterator prev_layer_it(temp_prev_layer->begin());
-                current_neuron->activate(prev_layer_it, h_activ);
-            }
+            results.push_back( distance( output_layer->begin(), max_element(output_layer->begin(),output_layer->end(),neuron_cmp) ) );
         }
     }
-    list<forward_list<Neuron>>::iterator output_layer = layers.end(); output_layer--;
-    if(as_raw)
-    {
-        return max_element(output_layer->begin(), output_layer->end(), neuron_cmp)->get_activated_output();
-    }else
-    {
-        return distance( output_layer->begin(), max_element(output_layer->begin(),output_layer->end(),neuron_cmp) );
-    }
+    return results;
 }
 
 void Network::print()

annclasses.h

@@ -1,5 +1,5 @@
-#ifndef MYCLASSES_H
-#define MYCLASSES_H
+#ifndef ANNCLASSES_H
+#define ANNCLASSES_H
 
 #include <forward_list>
 #include <list>
@@ -39,10 +39,12 @@ class Network
 public:
     Network(int n_layers, int n_neurons);
     Network(const std::vector<int> &n_neurons, Activ h_activ=RELU, Activ o_activ=SIGMOID);
+
+    int get_neurons_number();
     
-    bool train(const std::vector<float> &input, const std::vector<float> &target, float learning_rate, int n_episodes);
+    bool train(const std::vector<std::vector<float>> &inputs, const std::vector<std::vector<float>> &targets, float learning_rate=0.001, int n_episodes=30, int batch_size=32);
 
-    float predict(const std::vector<float> &input, bool as_raw=true);
+    std::vector<float> predict(const std::vector<std::vector<float>> &inputs, bool as_raw=true);
     void print();
 
     //to be deleted
@@ -51,6 +53,7 @@ public:
     //bool backward(float learning_rate);
 private:
     std::list<std::forward_list<Neuron>> layers;
+    int neurons_number;
     Activ h_activ;
     Activ o_activ;
 

main.cpp

@@ -11,14 +11,21 @@ int main(int argc, char *argv[])
 
     cout << "Bonjour et bienvenu" << endl;
     
-    Network network(15, 3);
+    Network network(15, 3);/*
     network.print();
     cout << endl << endl;
     network.train({1.0,1.0,1.0}, {1.0,2.0,3.0}, 0.001, 100000);
     //network.print();
     cout << endl << endl;
-    network.print();
-    cout << "verdict : " << network.predict({1.0,1.0,1.0},false) << endl;
+    network.print();*/
+    cout << "Network has " << network.get_neurons_number() << " neurons" << endl;
+    for(auto e : network.predict({{1.0,1.0,1.0},{2.0,1.3,0.0}},false))
+    {
+        cout << e << " " << endl;
+    }
+
+    //vector<vector<float>> v(5);
+    //cout << v.at(0).size() << endl;
 
     return 0;
 }