From e9defa3b861f156f35948ac54b5b97309d6ea024 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Asr=C4=B1n=20Do=C4=9Fan?= <33391270+Syntriax@users.noreply.github.com> Date: Sun, 15 Dec 2019 15:57:34 +0300 Subject: [PATCH] Rewrite --- main.cpp | 811 +++++++++++++++++-------------------------------------- 1 file changed, 241 insertions(+), 570 deletions(-) diff --git a/main.cpp b/main.cpp index 1c011da..f4fdbb3 100644 --- a/main.cpp +++ b/main.cpp @@ -1,7 +1,12 @@ #include -#include #include +class Synapse; +class Neuron; +class Layer; +class Input; +class Output; +class NeuralNetwork; float RandomFloat(int min, int max) { @@ -11,473 +16,273 @@ float RandomFloat(int min, int max) srand(time(0) + counter++ * 50); value = (rand() % ((max - min) * 100)); result = (float)value / 100.0 + (float)min; - std::clog << "Function RandomFloat: Between " << min << " and " << max << " returned value is " << result << "\n"; - return 1.0; + return result; } -#pragma region Sinaps - class Sinaps +#pragma region Synapse + class Synapse { private: - float weight; // Ağırlık - float value; // Değer - float bias; // Öteleme + float weight; + float value; + float bias; public: - Sinaps(); - ~Sinaps(); - Sinaps(float, float, float); // Kaydedilen değerleri yeniden yazabilmek için - void SetSinaps(float, float, float); // Sonradan tamamen değiştirebilmek için - void SetWeight(float); + Synapse(); void SetValue(float); + void SetWeight(float); void SetBias(float); float Fire(); }; - - Sinaps::Sinaps() - { - // weight = value = bias = 0.0; - this -> weight = RandomFloat(-1, 1); - this -> value = RandomFloat(-1, 1); - this -> bias = RandomFloat(-1, 1); - std::clog << "Create Sinaps: Weight = " << weight - << " Value = " << value - << " Bias = " << bias << "\n" << "\n"; - } - Sinaps::~Sinaps() + Synapse::Synapse() { - std::clog << "Delete Sinaps: Weight = " << weight - << " Value = " << value - << " Bias = " << bias << "\n"; - } - Sinaps::Sinaps(float weight, float value, float bias) - { - this -> weight = weight; - this -> value = value; - this -> bias = bias; - std::clog << "Create Sinaps: Weight = " << weight - << " Value = " << value - << " Bias = " << bias << "\n"; + this -> value = this -> weight = this -> bias = 1.0; } - void Sinaps::SetSinaps(float weight, float value, float bias) - { - this -> weight = weight; + void Synapse::SetValue(float value) + { this -> value = value; - this -> bias = bias; - std::clog << "\n" << "Set Sinaps: Weight = " << weight - << " Value = " << value - << " Bias = " << bias << "\n"; - } - void Sinaps::SetWeight(float weight) { std::clog << "Set Sinaps Weight: " << weight << "\n"; this -> weight = weight; } - void Sinaps::SetValue(float value) { std::clog << "Set Sinaps Value: " << value << "\n"; this -> value = value; } - void Sinaps::SetBias(float bias) { std::clog << "Set Sinaps Bias: " << bias << "\n"; this -> bias = bias; } + } - float Sinaps::Fire() - { - float result = weight * value + bias; - std::clog << "Return Sinaps Fire: " << weight << " * " << - value << " + " << - bias << " = " << - result << "\n"; + void Synapse::SetWeight(float weight) + { + this -> weight = weight; + } + + void Synapse::SetBias(float bias) + { + this -> bias = bias; + } + + float Synapse::Fire() + { + float result = 0.0; + + result = this -> value * this -> weight + this -> bias; + return result; } #pragma endregion -#pragma region Noron - class Noron +#pragma region Neuron + class Neuron { private: - Sinaps *forwards; - Sinaps *incoming; - int forwardsCount; - int incomingCount; + Synapse *incomings; + Synapse *forwards; + int incomingsSize; + int forwardsSize; + int layerSize; + float value; public: - Noron(); - ~Noron(); - bool SetForwards(Sinaps *, int); - bool SetIncoming(Sinaps *, int); - float GetStatus(); + Neuron(); + void ConnectIncomings(Synapse *, int); + void ConnectForwards(Synapse *, int, int); + void SetValue(float); + float GetValue(); }; - Noron::Noron() + Neuron::Neuron() { - forwards = incoming = NULL; - forwardsCount = incomingCount = 0; - std::clog << "Create Noron: NULL" << "\n"; + incomings = forwards = NULL; + incomingsSize = forwardsSize = layerSize = 0; + value = 0.0; } - Noron::~Noron() + void Neuron::SetValue(float value) { - delete forwards; - delete incoming; + this -> value = value; } - bool Noron::SetForwards(Sinaps *newForwards, int size) + void Neuron::ConnectIncomings(Synapse *incomings, int incomingsSize) { - std::clog << "\n" << "SetForwards: Allocating Memory of Size " << size << " Sinapses" << "\n"; - if(forwards) - { - delete forwards; - forwards = NULL; - std::clog << "SetForwards: Old Forwards Has Been Deleted!" << "\n"; - } - forwards = (Sinaps *)new char[sizeof(Sinaps) * size]; - - if(!forwards) - { - std::clog << "SetForwards: Memory Couldn't Allocated!" << "\n"; - return false; - } - std::clog << "SetForwards: Memory Allocated!" << "\n"; - - for (int i = 0; i < size; i++) - *(forwards+i) = *(newForwards+i); - - forwardsCount = size; - std::clog << "SetForwards: Successfull!" << "\n"; - return true; + this -> incomings = incomings; + this -> incomingsSize = incomingsSize; + } + + void Neuron::ConnectForwards(Synapse *forwards, int forwardsSize, int layerSize) + { + this -> forwards = forwards; + this -> forwardsSize = forwardsSize; + this -> layerSize = layerSize; } - bool Noron::SetIncoming(Sinaps *newIncoming, int size) + float Neuron::GetValue() { - std::clog << "\n" << "SetIncoming: Allocating Memory of Size " << size << " Sinapses" << "\n"; - - if(incoming) - { - delete incoming; - incoming = NULL; - std::clog << "SetIncoming: Old Incoming Has Been Deleted!" << "\n"; - } - incoming = (Sinaps *)new char[sizeof(Sinaps) * size]; - - if(!incoming) - { - std::clog << "SetIncoming: Memory Couldn't Allocated!" << "\n"; - return false; - } - std::clog << "SetIncoming: Memory Allocated!" << "\n"; + float result = 0.0; - for (int i = 0; i < size; i++) - *(incoming+i) = *(newIncoming+i); - - incomingCount = size; - std::clog << "SetIncoming: Successfull!" << "\n"; - return true; - } + if(!incomings) return (value = result); - float Noron::GetStatus() - { - std::clog << "\n" << "GetStatus: Called!" << "\n"; - float toplam = 0.0; - - std::clog << "GetStatus: Firing All Sinapses!" << "\n" << "\n"; - for (int i = 0; i < incomingCount; i++) - { - std::clog << "GetStatus: Firing Sinaps " << i << "\n"; - toplam += (incoming + i) -> Fire(); - } + for (int i = 0; i < incomingsSize; i++) + result += (incomings + i) -> Fire(); - for (int i = 0; i < forwardsCount; i++) - { - std::clog << "GetStatus: Setting Value of Sinaps " << i << " to " << toplam << "\n"; - (forwards + i) -> SetValue(toplam); - } - std::clog << "Get Noron Status: Sum = " << toplam << "\n"; - return toplam; + if(!forwards) return (value = result); + + for (int i = 0; i < forwardsSize; i++) + // currentSynapse = (forwards -> synapses + (forwardNeuron * this -> neuronSize)); + // (forwards + i) -> SetValue(result); + //BAK BURAYA + (forwards + i * layerSize) -> SetValue(result); + + value = result; + return result; } #pragma endregion -#pragma region Katman - class Katman +#pragma region Layer + class Layer { protected: - Noron *neurons; - Katman *forward; - Sinaps *layerSinapses; - int size; - Sinaps *CreateSinapsSet(int size); + Neuron *neurons; + Synapse *synapses; + int neuronSize; + int synapseSize; + Neuron *_CreateNeurons(int); public: - Katman(); - Katman(int); - ~Katman(); + Layer(); + Layer(int); + ~Layer(); void FireLayer(); - void RandomizeSinapsValues(); - bool SetForward(Katman *); - bool SetIncoming(Sinaps *sinapsSet, int backwardsNeuronCount); - bool SetNoron(Noron *, int); - bool CreateNoron(int); + bool CreateNeurons(int); + bool ConnectPrevious(Layer *); + bool ConnectForwards(Layer *); int GetSize(); }; - Katman::Katman() + Layer::Layer() { - neurons = NULL; - forward = NULL; - layerSinapses = NULL; - this -> size = 0; - std::clog << "Create Layer: NULL" << "\n"; + neuronSize = synapseSize = 0; + neurons = NULL; + synapses = NULL; } - Katman::Katman(int size) - { - neurons = NULL; - forward = NULL; - layerSinapses = NULL; - this -> size = 0; - - if(!CreateNoron(size)) - { - std::clog << "Error Create Layer: Neurons Couldn't Created!" << "\n"; - std::cout << "Katman Oluşturulamadı!" << "\n"; - return; - } - - std::clog << "Create Layer: " << size << " Neurons Has Been Created!" << "\n"; - this -> size = size; - } - Katman::~Katman() { delete neurons; } - - Sinaps *Katman::CreateSinapsSet(int size) + Layer::Layer(int size) { - std::clog << "\n" << "CreateSinapsSet: Allocating Memory Size of " << size << " Sinapses" << "\n"; - Sinaps* sinapses = new Sinaps[size]; + neuronSize = synapseSize = 0; + synapses = NULL; + neurons = _CreateNeurons(size); + } + + Layer::~Layer() + { + if(neurons) delete neurons; + if(synapses) delete synapses; + } - if(sinapses) - std::clog << "Create Sinaps Set: Memory Size of " << size << " Sinapses Allocated!" << "\n"; - else - std::clog << "Error Create Sinaps Set!" << "\n"; + Neuron *Layer::_CreateNeurons(int size) + { + Neuron *newNeurons = NULL; + newNeurons = (Neuron *) new char[sizeof(Neuron) * size]; - return sinapses; + if(newNeurons) + for (int i = 0; i < size; i++) + *(newNeurons + i) = Neuron(); + + return newNeurons; } - void Katman::RandomizeSinapsValues() + + void Layer::FireLayer() { - if(!forward) - return; - - float weight = 0; - float value = 0; - float bias = 0; - - int sinapsCount = size * (forward -> GetSize()); - for (int i = 0; i < sinapsCount; i++) - { - weight = RandomFloat(-1, 1); - value = RandomFloat(-1, 1); - bias = RandomFloat(-1, 1); - - (layerSinapses + i) -> SetSinaps(weight, value, bias); - std::clog << "RandomizeSinapsValues: SetSinaps Called With Values of SetSinaps(" << weight << ", " << value << ", " << bias << ")" << "\n"; - } + for (int i = 0; i < neuronSize; i++) + (neurons + i) -> GetValue(); } - void Katman::FireLayer() + bool Layer::CreateNeurons(int size) { - std::clog << "\n" << "FireLayer: Number of " << size << " Neurons' GetStatus is Being Called!" << "\n"; - for (int i = 0; i < size; i++) - std::clog << i << ". Neuron Status: " << (neurons + i) -> GetStatus() << "\n"; + if(neurons = _CreateNeurons(size)) + neuronSize = size; + return neurons; } - bool Katman::SetForward(Katman *forward) - { - std::clog << "\n" << "SetForward: Called!" << "\n"; - Sinaps *sinapses = NULL; // Pointer to store all created sinapses - Sinaps *newSinapses = NULL; // Temporary Pointer for creating each neurons' s1inapses - int forwardSize = 0; - if(layerSinapses) - { - delete layerSinapses; - layerSinapses = NULL; - std::clog << "SetForward: Old layerSinapses Has Been Deleted!" << "\n"; - } + bool Layer::ConnectPrevious(Layer *previous) + { + int previousSize = previous -> GetSize(); + int synapseCount = (this -> neuronSize) * previousSize; + int currentIndex = 0; + Synapse *currentSynapse = NULL; + Neuron *currentNeuron = NULL; + // Synapse *connectSynapses = NULL; - this -> forward = forward; - - if(!forward) - { - std::clog << "SetForward: Forward is NULL" << "\n"; - return true; - } + if(synapses) delete synapses; + synapses = (Synapse *) new char[sizeof(Synapse) * synapseCount]; + if(!synapses) return false; - forwardSize = forward -> GetSize(); - std::clog << "SetForward: Creating Sinaps Set with Number of " << (size * forwardSize) << "\n"; - if(sinapses) - { - delete sinapses; - sinapses = NULL; - std::clog << "SetForward: Old Sinapses Has Been Deleted!" << "\n"; - } - sinapses = (Sinaps *)new char[sizeof(Sinaps) * size * forwardSize]; + // connectSynapses = (Synapse *) new char[sizeof(Synapse) * previousSize]; - if(!sinapses) + for (int thisNeuron = 0; thisNeuron < this -> neuronSize; thisNeuron++) { - std::clog << "Error SetForward: Couldn't Allocate Memory for Sinapses!" << "\n"; - return false; - } - std::clog << "SetForward: SinapsSet Created!" << "\n"; - - // Set Forwards of each neuron in the Layer - for (int thisCounter = 0; thisCounter < size; thisCounter++) - { - newSinapses = CreateSinapsSet(forwardSize); - - if(!newSinapses) + for (int prevNeuron = 0; prevNeuron < previousSize; prevNeuron++) { - std::clog << "SetForward -> CreateSinapsSet: Couldn't Allocate Memory for Sinapses!" << "\n"; - return false; + currentIndex = thisNeuron * previousSize + prevNeuron; + currentSynapse = (synapses + currentIndex); + currentNeuron = (previous -> neurons) + prevNeuron; + + *currentSynapse = Synapse(); + // currentSynapse = (Synapse *) new char[sizeof(Synapse)]; + // currentSynapse -> SetWeight(1); + // currentSynapse -> SetValue(2); + // currentSynapse -> SetBias(3); + // currentSynapse -> SetRoot(currentNeuron); } - std::clog << "SetForward -> CreateSinapsSet: SinapsSet Created!" << "\n"; - std::clog << "SetForward -> SetForwards: " << - (neurons + thisCounter) -> SetForwards(newSinapses, forwardSize) - << "\n";; - - - // Add each sinaps to the array - for (int forwardCounter = 0; forwardCounter < forwardSize; forwardCounter++) - *(sinapses + forwardCounter) = *(newSinapses + forwardCounter); - std::clog << "SetForward: Sinapses Are Added to the Array!" << "\n"; + currentNeuron = (neurons + thisNeuron); + currentNeuron -> ConnectIncomings((synapses + thisNeuron * previousSize), previousSize); } - layerSinapses = sinapses; - std::clog << "SetForward: Sinaps Array Has Been Set to the Class' Pointer!" << "\n"; - // Send the sinapses to the forward layer - return forward -> SetIncoming(sinapses, size); + return previous -> ConnectForwards(this); } - - bool Katman::SetIncoming(Sinaps *sinapsSet, int backwardsNeuronCount) + + bool Layer::ConnectForwards(Layer *forwards) { - Sinaps *sinapses = NULL; - int sinapcCounter = 0; - - std::clog << "\n" << "SetIncoming: Creating Sinaps Set with Number of " << backwardsNeuronCount << "\n"; - if(sinapses) - { - delete sinapses; - sinapses = NULL; - std::clog << "SetIncoming: Old Sinapses Has Been Deleted!" << "\n"; - } - sinapses = (Sinaps *)new char[sizeof(Sinaps) * backwardsNeuronCount]; + int forwardsSize = forwards -> neuronSize; + Neuron *currentNeuron = NULL; - if(!sinapses) + for (int thisNeuron = 0; thisNeuron < this -> neuronSize; thisNeuron++) { - std::clog << "Error SetIncoming: Couldn't Allocate Memory for Sinapses!" << "\n"; - return false; + currentNeuron = (neurons + thisNeuron); + for (int forwardNeuron = 0; forwardNeuron < forwardsSize; forwardNeuron++) + currentNeuron -> ConnectForwards(forwards -> synapses + thisNeuron, forwardsSize, this -> neuronSize); + // currentSynapse = (forwards -> synapses + (thisNeuron + forwardNeuron * this -> neuronSize)); } - std::clog << "SetIncoming: SinapsSet Created!" << "\n"; - - for (int thisCounter = 0; thisCounter < size; thisCounter++) - { - std::clog << "SetIncoming: Sinapses Are Being Added to the Array!" << "\n"; - // Add each sinaps to the array - for (int incomingCounter = 0; incomingCounter < backwardsNeuronCount; incomingCounter++) - *(sinapses + incomingCounter) = *(sinapsSet + sinapcCounter++); - - std::clog << "SetIncoming -> Neuron SetIncoming: " << - (neurons + thisCounter) -> SetIncoming(sinapses, backwardsNeuronCount) - << "\n"; - } - return true; } - bool Katman::SetNoron(Noron *newNeurons, int size) + int Layer::GetSize() { - std::clog << "\n" << "SetNoron: Creating Neurons with Number of " << size << "\n"; - if(neurons) - { - delete neurons; - neurons = NULL; - std::clog << "SetNoron: Old Neurons Has Been Deleted!" << "\n"; - } - neurons = (Noron *) new char[sizeof(Noron) * size]; - - if(!neurons) - { - std::clog << "Error SetNoron: Creating Neurons Failed!" << "\n"; - return false; - } - std::clog << "SetNoron: Neurons Created Successfully!" << "\n"; - - std::clog << "SetNoron: Setting Neurons to the Class' Neurons!" << "\n"; - for (int i = 0; i < size; i++) - *(neurons+i) = *(newNeurons+i); - - std::clog << "SetNoron: Neurons are Set Successfully!" << "\n"; - this -> size = size; - return true; + return neuronSize; } - - bool Katman::CreateNoron(int size) - { - std::clog << "\n" << "CreateNoron: Creating Neurons with Number of " << size << "\n"; - if(neurons) - { - delete neurons; - neurons = NULL; - std::clog << "CreateNoron: Old Neurons Has Been Deleted!" << "\n"; - } - neurons = new Noron[size]; - - if(!neurons) - { - std::clog << "Error CreateNoron: Creating Neurons Failed!" << "\n"; - return false; - } - std::clog << "CreateNoron: Neurons Created Successfully!" << "\n"; - - std::clog << "CreateNoron: Neurons are Set Successfully!" << "\n"; - this -> size = size; - return true; - } - - int Katman::GetSize() { return size; } -#pragma endregion -#pragma region Girdi-Cikti - #pragma region Girdi - class Girdi : public Katman + #pragma region Input-Output + class Input : public Layer { public: - Girdi(); - Girdi(int); + Input(); void SetValue(int, float); }; - - Girdi::Girdi() : Katman(1) { std::clog << "\n" << "Create Input Layer: Called!" << "\n"; } - Girdi::Girdi(int size) : Katman(size) {} - - void Girdi::SetValue(int index, float value) + + Input::Input() : Layer() {} + void Input::SetValue(int index, float value) { - Sinaps *editedSinaps = NULL; - int forwardNeuronCount = forward -> GetSize(); - std::clog << "\n" << "SetValue: Index of " << index << " Neuron's Sinapses Values are Getting Set to Value of " << value << "\n"; + if(index >= this -> neuronSize || index < 0) + return; - for (int i = 0; i < forwardNeuronCount; i++) - { - std::clog << "SetValue -> Sinaps SetValue: Index of " << index << " Neuron's " << i << " Sinaps Value is Getting Set to Value of " << value << "\n"; - editedSinaps = (layerSinapses + index * forwardNeuronCount + i); - editedSinaps -> SetValue(value); - std::clog << "SetValue -> Sinaps SetValue: Successfull" << "\n"; - } - std::clog << "SetValue: Successfull" << "\n"; + (neurons + index) -> SetValue(value); } - #pragma endregion - #pragma region Cikti - class Cikti : public Katman + + class Output : public Layer { public: - Cikti(); - Cikti(int); + Output(); float GetValue(int); }; - - Cikti::Cikti() : Katman(1) { std::clog << "\n" << "Create Output Layer: Called!" << "\n"; } - Cikti::Cikti(int size) : Katman(size) {} - - float Cikti::GetValue(int index) + + Output::Output() : Layer() {} + float Output::GetValue(int index) { - std::clog << "\n" << "Call GetValue!" << "\n"; - float result = (neurons + index) -> GetStatus(); - std::clog << "GetValue: " << result << "\n"; + float result = 0.0; + + if(index >= this -> neuronSize || index < 0) + return result; + + result = (neurons + index) -> GetValue(); return result; } #pragma endregion @@ -486,244 +291,110 @@ float RandomFloat(int min, int max) class NeuralNetwork { private: - Girdi *input; - Katman *hiddenLayers; - Cikti *output; + Input *input; + Layer *hidden; + Output *output; int hiddenSize; + public: NeuralNetwork(); NeuralNetwork(int); ~NeuralNetwork(); - void SetInput(int, float); - void RandomizeNetworkValues(); void FireNetwork(); bool SetInputNeurons(int); - bool SetHiddenLayerNeurons(int, int); + bool SetHiddenNeurons(int, int); bool SetOutputNeurons(int); bool ConnectLayers(); - float GetOutputValue(int); + float GetOutput(int); + void SetInput(int, float); }; NeuralNetwork::NeuralNetwork() { - std::clog << "\n" << "Create NeuralNetwork: NULL" << "\n"; hiddenSize = 0; input = NULL; - hiddenLayers = NULL; + hidden = NULL; output = NULL; } NeuralNetwork::NeuralNetwork(int hiddenSize) { - std::clog << "\n" << "Create NeuralNetwork: Called" << "\n"; - input = new Girdi(); - hiddenLayers = new Katman[hiddenSize]; - output = new Cikti(); - std::clog << "\n" << "Create NeuralNetwork: New Neural Network Created with " << hiddenSize << " Layers!" << "\n"; - - if(!input) - { - std::clog << "Error Create NeuralNetwork: Memory Couldn't Allocated for Input Layer!" << "\n"; - std::cout << "Girdi Katmani Olusturulamadi!" << "\n"; - } - if(!hiddenLayers) - { - std::clog << "Error Create NeuralNetwork: Memory Couldn't Allocated for Hidden Layers!" << "\n"; - std::cout << "Ara Katmanlar Olusturulamadi!" << "\n"; - } - if(!output) - { - std::clog << "Error Create NeuralNetwork: Memory Couldn't Allocated for Output Layer!" << "\n"; - std::cout << "Cikti Katmani Olusturulamadi!" << "\n"; - } - - if(!input || !hiddenLayers || !output) - return; - - std::clog << "Create NeuralNetwork: Succesfull!" << "\n"; this -> hiddenSize = hiddenSize; + input = new Input(); + hidden = new Layer(hiddenSize); + output = new Output(); } NeuralNetwork::~NeuralNetwork() { - delete input; - delete hiddenLayers; - delete output; - } - - bool NeuralNetwork::SetHiddenLayerNeurons(int index, int size) - { - bool result; - std::clog << "\n" << "SetHiddenLayerNeurons: Size of " << size << " at Index of " << index << "\n"; - std::clog << "SetHiddenLayerNeurons: Allocating Memory Size of " << size << " Neurons!" << "\n"; - Noron *neurons = (Noron *) new char[sizeof(Noron) * size]; - - if(!neurons) - { - std::clog << "Error SetHiddenLayerNeurons: Couldn't Allocate Memory for Neurons!" << "\n"; - return false; - } - std::clog << "SetHiddenLayerNeurons: Memory Allocated!" << "\n"; - std::clog << "SetHiddenLayerNeurons -> CreateNoron: Called!" << "\n"; - result = (hiddenLayers + index) -> CreateNoron(size); - std::clog << "SetHiddenLayerNeurons -> CreateNoron: " << result << "\n"; - // if(result) - // return (hiddenLayers + index) -> SetNoron(neurons, size); - return result; - } - - bool NeuralNetwork::SetInputNeurons(int size) - { - bool result; - std::clog << "\n" << "SetInputNeurons: Size of " << size << "\n"; - std::clog << "SetInputNeurons: Allocating Memory Size of " << size << " Neurons!" << "\n"; - Noron *neurons = (Noron *) new char[sizeof(Noron) * size]; - - if(!neurons) - { - std::clog << "Error SetInputNeurons: Couldn't Allocate Memory for Neurons!" << "\n"; - return false; - } - std::clog << "SetInputNeurons: Memory Allocated!" << "\n"; - std::clog << "SetInputNeurons -> CreateNoron: Called!" << "\n"; - result = input -> CreateNoron(size); - std::clog << "SetInputNeurons -> CreateNoron: " << result << "\n"; - // return output -> SetNoron(neurons, size); - return result; - } - - bool NeuralNetwork::SetOutputNeurons(int size) - { - bool result; - std::clog << "\n" << "SetOutputNeurons: Size of " << size << "\n"; - std::clog << "SetOutputNeurons: Allocating Memory Size of " << size << " Neurons!" << "\n"; - Noron *neurons = (Noron *) new char[sizeof(Noron) * size]; - - if(!neurons) - { - std::clog << "Error SetOutputNeurons: Couldn't Allocate Memory for Neurons!" << "\n"; - return false; - } - std::clog << "SetOutputNeurons: Memory Allocated!" << "\n"; - - std::clog << "SetOutputNeurons -> CreateNoron: Called!" << "\n"; - result = input -> CreateNoron(size); - std::clog << "SetOutputNeurons -> CreateNoron: " << result << "\n"; - // return input -> SetNoron(neurons, size); - return result; - } - - bool NeuralNetwork::ConnectLayers() - { - if(!input -> SetForward(hiddenLayers)) - { - std::clog << "\n" << "Error ConnectLayers: Input Couldn't Set to Forward!" << "\n"; - return false; - } - std::clog << "\n" << "ConnectLayers: Input is Set to Forward Successfully!" << "\n"; - - for (int i = 0; i < hiddenSize - 1; i++) - if(!(hiddenLayers + i) -> SetForward(hiddenLayers + i + 1)) - { - std::clog << "Error ConnectLayers: Hidden Layer " << i << " Couldn't Set to Forward!" << "\n"; - return false; - } - else - std::clog << "ConnectLayers: Hidden Layer " << i << " is Set to Forward Successfully!" << "\n"; - - std::clog << "ConnectLayers: Hidden Layers are Set to Forward Successfully!" << "\n"; - - if(!(hiddenLayers + hiddenSize - 1) -> SetForward(output)) - { - std::clog << "Error ConnectLayers: Output Couldn't Set to Forward!" << "\n"; - return false; - } - std::clog << "ConnectLayers: Output is Set to Forward Successfully!" << "\n"; - - return output -> SetForward(NULL); + if(input) delete input; + if(hidden) delete hidden; + if(output) delete output; } void NeuralNetwork::FireNetwork() { - // input -> FireLayer(); - // std::clog << "\n" << "FireNetwork: Input Fired!" << "\n"; - for (int i = 0; i < hiddenSize; i++) - { - (hiddenLayers + i) -> FireLayer(); - std::clog << "FireNetwork: Hidden Layer " << i << " Fired!" << "\n"; - } - + (hidden + i) -> FireLayer(); + output -> FireLayer(); - std::clog << "FireNetwork: Output Fired!" << "\n"; } + bool NeuralNetwork::SetInputNeurons(int size) + { + return input -> CreateNeurons(size); + } + + bool NeuralNetwork::SetHiddenNeurons(int index, int size) + { + return (hidden + index) -> CreateNeurons(size); + } + + bool NeuralNetwork::SetOutputNeurons(int size) + { + return output -> CreateNeurons(size); + } + + bool NeuralNetwork::ConnectLayers() + { + if(!hidden -> ConnectPrevious(input)) + return false; + + for (int i = 1; i < hiddenSize; i++) + if(!(hidden + i) -> ConnectPrevious((hidden + i - 1))) + return false; + + if(output -> ConnectPrevious((hidden + hiddenSize - 1))) + return false; + + return true; + } + + float NeuralNetwork::GetOutput(int index) + { + return output -> GetValue(index); + } + void NeuralNetwork::SetInput(int index, float value) { - if(!input) - { - std::clog << "\n" << "SetInput: There's no Input Layer Set!" << "\n"; - return; - } - - std::clog << "\n" << "SetInput -> Input SetValue: SetValue(" << index << ", " << value << ")!" << "\n"; input -> SetValue(index, value); } - - void NeuralNetwork::RandomizeNetworkValues() - { - std::clog << "\n" << "RandomizeNetworkValues: Input Sinapses Are Getting Randomized!" << "\n"; - input -> RandomizeSinapsValues(); - - for (int i = 0; i < hiddenSize; i++) - { - std::clog << "RandomizeNetworkValues: Hidden Layer " << i << " Sinapses Are Getting Randomized!" << "\n"; - (hiddenLayers + i) -> RandomizeSinapsValues(); - } - - std::clog << "RandomizeNetworkValues: Output Sinapses Are Getting Randomized!" << "\n"; - output -> RandomizeSinapsValues(); - } - - float NeuralNetwork::GetOutputValue(int index) - { - float result = output -> GetValue(index); - std::clog << "\n" << "GetOutputValue: " << result << "\n"; - return result; - } #pragma endregion + + int main(int argc, char const *argv[]) { - float result; - FILE *file; NeuralNetwork network(3); network.SetInputNeurons(1); - network.SetHiddenLayerNeurons(0, 2); - network.SetHiddenLayerNeurons(1, 3); - network.SetHiddenLayerNeurons(2, 2); + network.SetHiddenNeurons(0, 2); + network.SetHiddenNeurons(1, 3); + network.SetHiddenNeurons(2, 2); network.SetOutputNeurons(1); network.ConnectLayers(); - std::cout << "m1\n"; - network.RandomizeNetworkValues(); - std::cout << "m2\n"; - - network.SetInput(0, 1); - std::cout << "m3\n"; - + network.SetInput(0, 2); network.FireNetwork(); - result = network.GetOutputValue(0); - std::cout << "Output is " << result << "\n"; - file = fopen("result.txt", "w"); - fprintf(file, "%f", result); - fclose(file); - - // std::cout << "Sinaps = " << sizeof(Sinaps) * 30 << "\n"; - // std::cout << "Noron = " << sizeof(Noron) * 9 << "\n"; - // std::cout << "Katman = " << sizeof(Katman) * 3 << "\n"; - // std::cout << "Girdi = " << sizeof(Girdi) * 1 << "\n"; - // std::cout << "Cikti = " << sizeof(Cikti) * 1 << "\n"; - // std::cout << "NeuralNetwork = " << sizeof(NeuralNetwork) * 1 << "\n"; + std::cout << "Result = " << network.GetOutput(0) << "\n"; return 0; }