Generations Part 1

Genetic.cpp

@@ -2,7 +2,7 @@
 #include <time.h>
 
 #define RandomRange 1
-#define InitialSynapseValue 1.0
+#define InitialSynapseValue 0.0
 #define MutationRate 0.0001
 
 class Synapse;
@@ -20,6 +20,7 @@ float RandomFloat(int min, int max)
     srand(time(0) * counter++);
     value = ((rand() * counter) % ((max - min) * 100000));
     result = (float)value / 100000.0 + (float)min;
+    // std::cout << "random is " << result << "\n";
     return result;
 }
 
@@ -281,11 +282,11 @@ float RandomFloat(int min, int max)
         {
             public:
                 Input();
-                void SetValue(int, float);
+                void SetValue(float, int);
         };
 
         Input::Input() : Layer() {}
-        void Input::SetValue(int index, float value)
+        void Input::SetValue(float value, int index = 0)
         {
             if(index >= this -> neuronSize || index < 0)
                 return;
@@ -301,7 +302,7 @@ float RandomFloat(int min, int max)
         };
 
         Output::Output() : Layer() {}
-        float Output::GetValue(int index)
+        float Output::GetValue(int index = 0)
         {
             float result = 0.0;
 
@@ -333,7 +334,8 @@ float RandomFloat(int min, int max)
             bool SetOutputNeurons(int);
             bool ConnectLayers();
             float GetOutput(int);
-            void SetInput(int, float);
+            float GetScore(float, int);
+            void SetInput(float, int);
     };
 
     NeuralNetwork::NeuralNetwork()
@@ -374,7 +376,6 @@ float RandomFloat(int min, int max)
             (hidden + i) -> Mutate();
 
         output -> Mutate();
-        
     }
 
     void NeuralNetwork::RandomizeValues()
@@ -411,68 +412,194 @@ float RandomFloat(int min, int max)
             if(!(hidden + i) -> ConnectPrevious((hidden + i - 1)))
                 return false;
 
-        if(output -> ConnectPrevious((hidden + hiddenSize - 1)))
+        if(!output -> ConnectPrevious((hidden + hiddenSize - 1)))
             return false;
 
         return true;
     }
 
-    float NeuralNetwork::GetOutput(int index)
+    float NeuralNetwork::GetOutput(int index = 0)
     {
         return output -> GetValue(index);
     }
 
-    void NeuralNetwork::SetInput(int index, float value)
+    float NeuralNetwork::GetScore(float target, int index = 0)
     {
-        input -> SetValue(index, value);
+        float result = GetOutput(index) - target;
+        return result < 0.0 ? -result : result;
+    }
+
+    void NeuralNetwork::SetInput(float value, int index = 0)
+    {
+        input -> SetValue(value, index);
     }
 #pragma endregion
+#pragma region Generation
+    class Generation
+    {
+        private:
+            NeuralNetwork *networks;
+            int size;
+            int step;
+            float target;
+            void SwapNetworks(NeuralNetwork *, NeuralNetwork *);
+            NeuralNetwork *_CreateNetworks(int, int);
+        public:
+            Generation();
+            Generation(int, int);
+            ~Generation();
+            void Randomize();
+            void Fire();
+            void SortByScore(int);
+            void DisplayScores(int);
+            void SetTarget(float);
+            void SetInput(float, int);
+            bool CreateNetworks(int, int);
+            bool ConnectNetworks();
+            bool SetInputNeurons(int);
+            bool SetHiddenNeurons(int, int);
+            bool SetOutputNeurons(int);
+    };
 
+    Generation::Generation()
+    {
+        step = 0;
+        networks = NULL;
+        size = 0;
+        target = 0.0;
+    }
+
+    Generation::Generation(int size, int hiddenSizes)
+    {
+        step = 0;
+        target = 0.0;
+        this -> size = size;
+        networks = _CreateNetworks(size, hiddenSizes);
+    }
+
+    Generation::~Generation()
+    {
+        if(networks) delete networks;
+    }
+
+    NeuralNetwork *Generation::_CreateNetworks(int size, int hiddenSizes)
+    {
+        NeuralNetwork *newNetworks = NULL;
+        newNetworks = (NeuralNetwork *) new char[sizeof(NeuralNetwork) * size];
+
+        if(newNetworks)
+            for (int i = 0; i < size; i++)
+                *(newNetworks + i) = NeuralNetwork(hiddenSizes);
+
+        return newNetworks;
+    }
+
+    void Generation::Randomize()
+    {
+        for (int i = 0; i < this -> size; i++)
+            (networks + i) -> RandomizeValues();
+    }
+
+    void Generation::Fire()
+    {
+        for (int i = 0; i < this -> size; i++)
+            (networks + i) -> FireNetwork();
+    }
+
+    void Generation::SwapNetworks(NeuralNetwork *first, NeuralNetwork *second)
+    {
+        NeuralNetwork temp;
+        temp = *first;
+        *first = *second;
+        *second = temp;
+    }
+
+    void Generation::DisplayScores(int index = 0)
+    {
+        std::cout << "----Scores----\n";
+        for (int i = 0; i < this -> size; i++)
+            std::cout << i << " -> " << (networks + i) -> GetScore(target, index) << "\n";
+    }
+
+    void Generation::SortByScore(int index = 0)
+    {
+        for (int i = 0; i < size - 1; i++)
+            for (int j = i + 1; j < size; j++)
+                if((networks + i) -> GetScore(target, index) < (networks + j) -> GetScore(target, index))
+                    SwapNetworks((networks + i), (networks + j));
+    }
+
+    void Generation::SetTarget(float target)
+    {
+        this -> target = target;
+    }
+
+    void Generation::SetInput(float value, int index = 0)
+    {
+        for (int i = 0; i < this -> size; i++)
+            (networks + i) -> SetInput(value, index);
+    }
+
+    bool Generation::CreateNetworks(int size, int hiddenSizes)
+    {
+        if((networks = _CreateNetworks(size, hiddenSizes)))
+            this -> size = size;
+        return networks;
+    }
+
+    bool Generation::ConnectNetworks()
+    {
+        for (int i = 0; i < this -> size; i++)
+            if(!(networks + i) -> ConnectLayers())
+                return false;
+
+        return true;
+    }
+
+    bool Generation::SetInputNeurons(int size)
+    {
+        for (int i = 0; i < this -> size; i++)
+            if(!(networks + i) -> SetInputNeurons(size))
+                return false;
+        return true;
+    }
+
+    bool Generation::SetHiddenNeurons(int index, int size)
+    {
+        for (int i = 0; i < this -> size; i++)
+            if(!(networks + i) -> SetHiddenNeurons(index, size))
+                return false;
+        return true;
+    }
+
+    bool Generation::SetOutputNeurons(int size)
+    {
+        for (int i = 0; i < this -> size; i++)
+            if(!(networks + i) -> SetOutputNeurons(size))
+                return false;
+        return true;
+    }
+
+#pragma endregion
 
 int main(int argc, char const *argv[])
 {
-    NeuralNetwork network(3);
+    Generation generation(50, 3);
+    std::cout << "1 - " << generation.SetInputNeurons(1) << "\n";
+    std::cout << "2 - " << generation.SetHiddenNeurons(0, 2) << "\n";
+    std::cout << "3 - " << generation.SetHiddenNeurons(1, 3) << "\n";
+    std::cout << "4 - " << generation.SetHiddenNeurons(2, 2) << "\n";
+    std::cout << "5 - " << generation.SetOutputNeurons(1) << "\n";
+    std::cout << "6 - " << generation.ConnectNetworks() << "\n";
 
-    #pragma region Initialization
-        network.SetInputNeurons(1);
-        network.SetHiddenNeurons(0, 2);
-        network.SetHiddenNeurons(1, 3);
-        network.SetHiddenNeurons(2, 2);
-        network.SetOutputNeurons(1);
+    // generation.SetTarget(12.30);
 
-        network.ConnectLayers();
-    #pragma endregion
+    generation.DisplayScores();
+    generation.SortByScore();
 
-    #pragma region Fixed Bias&Weight
-        network.SetInput(0, 1);
-        network.FireNetwork();
-        std::cout << "Result = " << network.GetOutput(0) << "\n";
-
-        network.SetInput(0, 2);
-        network.FireNetwork();
-        std::cout << "Result = " << network.GetOutput(0) << "\n";
-
-        network.SetInput(0, 3);
-        network.FireNetwork();
-        std::cout << "Result = " << network.GetOutput(0) << "\n";
-    #pragma endregion
-    
-    #pragma region Randomized Bias&Weight
-        network.RandomizeValues();
-        std::cout << "Randomize Called!" << "\n";
-        network.FireNetwork();
-        std::cout << "Result = " << network.GetOutput(0) << "\n";
-        
-        network.MutateNetwork();
-        std::cout << "Mutate Called!" << "\n";
-        network.FireNetwork();
-        std::cout << "Result = " << network.GetOutput(0) << "\n";
-        
-        network.MutateNetwork();
-        std::cout << "Mutate Called!" << "\n";
-        network.FireNetwork();
-        std::cout << "Result = " << network.GetOutput(0) << "\n";
-    #pragma endregion
+    generation.Randomize();
+    generation.Fire();
+    generation.DisplayScores();
 
     return 0;
 }