From a2614c61c40d3f99ea9ab192daa2989ef6ceb1be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Asr=C4=B1n=20Do=C4=9Fan?= <33391270+Syntriax@users.noreply.github.com> Date: Sat, 14 Dec 2019 12:50:57 +0300 Subject: [PATCH] Fixes3 --- main.cpp | 257 +++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 166 insertions(+), 91 deletions(-) diff --git a/main.cpp b/main.cpp index c20354e..5c37a55 100644 --- a/main.cpp +++ b/main.cpp @@ -35,10 +35,13 @@ float RandomFloat(int min, int max) Sinaps::Sinaps() { - weight = value = bias = 0.0; + // 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"; + << " Bias = " << bias << "\n" << "\n"; } Sinaps::~Sinaps() @@ -62,18 +65,18 @@ float RandomFloat(int min, int max) this -> weight = weight; this -> value = value; this -> bias = bias; - std::clog << "Set Sinaps: Weight = " << weight + 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; } + void Sinaps::SetWeight(float weight) { std::clog << "\n" << "Set Sinaps Weight: " << weight << "\n"; this -> weight = weight; } + void Sinaps::SetValue(float value) { std::clog << "\n" << "Set Sinaps Value: " << value << "\n"; this -> value = value; } + void Sinaps::SetBias(float bias) { std::clog << "\n" << "Set Sinaps Bias: " << bias << "\n"; this -> bias = bias; } float Sinaps::Fire() { float result = weight * value + bias; - std::clog << "Return Sinaps Fire: " << weight << " * " << + std::clog << "\n" << "Return Sinaps Fire: " << weight << " * " << value << " + " << bias << " = " << result << "\n"; @@ -111,7 +114,13 @@ float RandomFloat(int min, int max) bool Noron::SetForwards(Sinaps *newForwards, int size) { - std::clog << "SetForwards: Allocating Memory of Size " << size << "\n"; + 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) @@ -131,7 +140,14 @@ float RandomFloat(int min, int max) bool Noron::SetIncoming(Sinaps *newIncoming, int size) { - std::clog << "SetIncoming: Allocating Memory of Size " << size << "\n"; + 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) @@ -159,7 +175,7 @@ float RandomFloat(int min, int max) for (int i = 0; i < forwardsCount; i++) (forwards + i) -> SetValue(toplam); - std::clog << "Get Noron Status: Sum = " << toplam << "\n"; + std::clog << "\n" << "Get Noron Status: Sum = " << toplam << "\n"; return toplam; } #pragma endregion @@ -197,7 +213,7 @@ float RandomFloat(int min, int max) if(!CreateNoron(size)) { std::clog << "Error Create Layer: Neurons Couldn't Created!" << "\n"; - std::cout << "Katman Oluşturulamadı!"; + std::cout << "Katman Oluşturulamadı!" << "\n"; return; } @@ -209,10 +225,11 @@ float RandomFloat(int min, int max) Sinaps *Katman::CreateSinapsSet(int size) { + std::clog << "\n" << "CreateSinapsSet: Allocating Memory Size of " << size << " Sinapses" << "\n"; Sinaps* sinapses = new Sinaps[size]; if(sinapses) - std::clog << "Create Sinaps Set: " << size << " Sinapses Has Been Created!" << "\n"; + std::clog << "Create Sinaps Set: Memory Size of " << size << " Sinapses Allocated!" << "\n"; else std::clog << "Error Create Sinaps Set!" << "\n"; @@ -223,9 +240,9 @@ float RandomFloat(int min, int max) if(!forward) return; - float weight; - float value; - float bias; + float weight = 0; + float value = 0; + float bias = 0; int sinapsCount = size * (forward -> GetSize()); for (int i = 0; i < sinapsCount; i++) @@ -235,43 +252,54 @@ float RandomFloat(int min, int max) bias = RandomFloat(-1, 1); (layerSinapses + i) -> SetSinaps(weight, value, bias); - std::clog << "Call RandomizeSinapsValues: SetSinaps Called With Values of SetSinaps(" << weight << ", " << value << ", " << bias << ")" << "\n"; + std::clog << "RandomizeSinapsValues: SetSinaps d With Values of SetSinaps(" << weight << ", " << value << ", " << bias << ")" << "\n"; } } void Katman::FireLayer() { - std::clog << "Call FireLayer: Number of " << size << " Neurons' GetStatus is Being Called!" << "\n"; + 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"; } 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; - int sinapsesIndex = 0; - delete layerSinapses; + int forwardSize = 0; + if(layerSinapses) + { + delete layerSinapses; + layerSinapses = NULL; + std::clog << "SetForward: Old layerSinapses Has Been Deleted!" << "\n"; + } this -> forward = forward; if(!forward) { - std::clog << "Call SetForward: Forward is NULL" << "\n"; + std::clog << "SetForward: Forward is NULL" << "\n"; return true; } forwardSize = forward -> GetSize(); - std::clog << "Call SetForward: Creating Sinaps Set with Number of " << (size * forwardSize) << "\n"; + 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]; if(!sinapses) { - std::clog << "Error Call SetForward: Couldn't Allocate Memory for Sinapses!" << "\n"; + std::clog << "Error SetForward: Couldn't Allocate Memory for Sinapses!" << "\n"; return false; } - std::clog << "Call SetForward: Sinapses Set Created!" << "\n"; + std::clog << "SetForward: SinapsSet Created!" << "\n"; // Set Forwards of each neuron in the Layer for (int thisCounter = 0; thisCounter < size; thisCounter++) @@ -280,23 +308,24 @@ float RandomFloat(int min, int max) if(!newSinapses) { - std::clog << "Call SetForward -> CreateSinapsSet: Couldn't Allocate Memory for Sinapses!" << "\n"; + std::clog << "SetForward -> CreateSinapsSet: Couldn't Allocate Memory for Sinapses!" << "\n"; return false; } - std::clog << "Call SetForward -> CreateSinapsSet: Sinapses Set Created!" << "\n"; + std::clog << "SetForward -> CreateSinapsSet: SinapsSet Created!" << "\n"; - std::clog << "Call SetForward -> SetForwards: " << + std::clog << "SetForward -> SetForwards: " << (neurons + thisCounter) -> SetForwards(newSinapses, forwardSize) - << "\n";; + << "\n";; + // Add each sinaps to the array for (int forwardCounter = 0; forwardCounter < forwardSize; forwardCounter++) - *(sinapses + (sinapsesIndex++)) = *(newSinapses + forwardCounter); - std::clog << "Call SetForward: Sinapses Are Added to the Array!" << "\n"; + *(sinapses + forwardCounter) = *(newSinapses + forwardCounter); + std::clog << "SetForward: Sinapses Are Added to the Array!" << "\n"; } layerSinapses = sinapses; - std::clog << "Call SetForward: Sinaps Array Has Been Set to the Class' Pointer!" << "\n"; + 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); } @@ -305,24 +334,30 @@ float RandomFloat(int min, int max) { Sinaps *sinapses = NULL; - std::clog << "Call SetIncoming: Creating Sinaps Set with Number of " << backwardsNeuronCount << "\n"; + 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]; if(!sinapses) { - std::clog << "Error Call SetIncoming: Couldn't Allocate Memory for Sinapses!" << "\n"; + std::clog << "Error SetIncoming: Couldn't Allocate Memory for Sinapses!" << "\n"; return false; } - std::clog << "Call SetIncoming: Sinapses Set Created!" << "\n"; + std::clog << "SetIncoming: SinapsSet Created!" << "\n"; for (int thisCounter = 0; thisCounter < size; thisCounter++) { - std::clog << "Call SetIncoming: Sinapses Are Being Added to the Array!" << "\n"; + 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 + (size * thisCounter + incomingCounter)) = *(sinapsSet + incomingCounter); + *(sinapses + incomingCounter) = *(sinapsSet + (size * thisCounter + incomingCounter)); - std::clog << "Call SetIncoming -> Neuron SetIncoming: " << + std::clog << "SetIncoming -> Neuron SetIncoming: " << (neurons + thisCounter) -> SetIncoming(sinapses, backwardsNeuronCount) << "\n"; } @@ -332,39 +367,50 @@ float RandomFloat(int min, int max) bool Katman::SetNoron(Noron *newNeurons, int size) { - std::clog << "Call SetNoron: Creating Neurons with Number of " << size << "\n"; + 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 Call SetNoron: Creating Neurons Failed!" << "\n"; + std::clog << "Error SetNoron: Creating Neurons Failed!" << "\n"; return false; } - std::clog << "Call SetNoron: Neurons Created Successfully!" << "\n"; + std::clog << "SetNoron: Neurons Created Successfully!" << "\n"; - std::clog << "Call SetNoron: Setting Neurons to the Class' Neurons!" << "\n"; + std::clog << "SetNoron: Setting Neurons to the Class' Neurons!" << "\n"; for (int i = 0; i < size; i++) *(neurons+i) = *(newNeurons+i); - std::clog << "Call SetNoron: Neurons are Set Successfully!" << "\n"; + std::clog << "SetNoron: Neurons are Set Successfully!" << "\n"; this -> size = size; return true; } bool Katman::CreateNoron(int size) { - std::clog << "Call CreateNoron: Creating Neurons with Number of " << size << "\n"; - + 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 Call CreateNoron: Creating Neurons Failed!" << "\n"; + std::clog << "Error CreateNoron: Creating Neurons Failed!" << "\n"; return false; } - std::clog << "Call CreateNoron: Neurons Created Successfully!" << "\n"; + std::clog << "CreateNoron: Neurons Created Successfully!" << "\n"; - std::clog << "Call CreateNoron: Neurons are Set Successfully!" << "\n"; + std::clog << "CreateNoron: Neurons are Set Successfully!" << "\n"; this -> size = size; return true; } @@ -381,23 +427,23 @@ float RandomFloat(int min, int max) void SetValue(int, float); }; - Girdi::Girdi() : Katman() {} + 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) { Sinaps *editedSinaps = NULL; int forwardNeuronCount = forward -> GetSize(); - std::clog << "Call SetValue: Index of " << index << " Neuron's Sinapses Values are Getting Set to Value of " << value << "\n"; + std::clog << "\n" << "SetValue: Index of " << index << " Neuron's Sinapses Values are Getting Set to Value of " << value << "\n"; for (int i = 0; i < forwardNeuronCount; i++) { - std::clog << "Call SetValue -> Sinaps SetValue: Index of " << index << " Neuron's " << i << " Sinaps Value is Getting Set to Value of " << value << "\n"; + 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 << "Call SetValue -> Sinaps SetValue: Successfull" << "\n"; + std::clog << "SetValue -> Sinaps SetValue: Successfull" << "\n"; } - std::clog << "Call SetValue: Successfull" << "\n"; + std::clog << "SetValue: Successfull" << "\n"; } #pragma endregion #pragma region Cikti @@ -409,13 +455,14 @@ float RandomFloat(int min, int max) float GetValue(int); }; - Cikti::Cikti() : Katman() {} + Cikti::Cikti() : Katman(1) { std::clog << "\n" << "Create Output Layer: Called!" << "\n"; } Cikti::Cikti(int size) : Katman(size) {} float Cikti::GetValue(int index) { + std::clog << "\n" << "Call GetValue!" << "\n"; float result = (neurons + index) -> GetStatus(); - std::clog << "Call GetValue: " << result << "\n"; + std::clog << "GetValue: " << result << "\n"; return result; } #pragma endregion @@ -444,7 +491,7 @@ float RandomFloat(int min, int max) NeuralNetwork::NeuralNetwork() { - std::clog << "Create NeuralNetwork: NULL" << "\n"; + std::clog << "\n" << "Create NeuralNetwork: NULL" << "\n"; hiddenSize = 0; input = NULL; hiddenLayers = NULL; @@ -453,10 +500,11 @@ float RandomFloat(int min, int max) NeuralNetwork::NeuralNetwork(int hiddenSize) { + std::clog << "\n" << "Create NeuralNetwork: Called" << "\n"; input = new Girdi(); hiddenLayers = new Katman[hiddenSize]; output = new Cikti(); - std::clog << "Create NeuralNetwork: New Neural Network Created with " << hiddenSize << " Layers!" << "\n"; + std::clog << "\n" << "Create NeuralNetwork: New Neural Network Created with " << hiddenSize << " Layers!" << "\n"; if(!input) { @@ -490,75 +538,89 @@ float RandomFloat(int min, int max) bool NeuralNetwork::SetHiddenLayerNeurons(int index, int size) { - std::clog << "Call SetHiddenLayerNeurons: Size of " << size << " at Index of " << index << "\n"; - std::clog << "Call SetHiddenLayerNeurons: Creating " << size << " Neurons!" << "\n"; + 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 Call SetHiddenLayerNeurons: Couldn't Allocate Memory for Neurons!" << "\n"; + std::clog << "Error SetHiddenLayerNeurons: Couldn't Allocate Memory for Neurons!" << "\n"; return false; } - std::clog << "Call SetHiddenLayerNeurons: Neurons Are Created!" << "\n"; - - return (hiddenLayers + index) -> SetNoron(neurons, size); + 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) { - std::clog << "Call SetInputNeurons: Size of " << size << "\n"; - std::clog << "Call SetInputNeurons: Creating " << size << " Neurons!" << "\n"; + 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 Call SetInputNeurons: Couldn't Allocate Memory for Neurons!" << "\n"; + std::clog << "Error SetInputNeurons: Couldn't Allocate Memory for Neurons!" << "\n"; return false; } - std::clog << "Call SetInputNeurons: Neurons Are Created!" << "\n"; - - return output -> SetNoron(neurons, size); + 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) { - std::clog << "Call SetInputNeurons: Size of " << size << "\n"; - std::clog << "Call SetInputNeurons: Creating " << size << " Neurons!" << "\n"; + 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 Call SetInputNeurons: Couldn't Allocate Memory for Neurons!" << "\n"; + std::clog << "Error SetOutputNeurons: Couldn't Allocate Memory for Neurons!" << "\n"; return false; } - std::clog << "Call SetInputNeurons: Neurons Are Created!" << "\n"; + std::clog << "SetOutputNeurons: Memory Allocated!" << "\n"; - return input -> SetNoron(neurons, size); + 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 << "Call ConnectLayers: Input Couldn't Set to Forward!" << "\n"; + std::clog << "\n" << "ConnectLayers: Input Couldn't Set to Forward!" << "\n"; return false; } - std::clog << "Call ConnectLayers: Input is Set to Forward Successfully!" << "\n"; + 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 << "Call ConnectLayers: Hidden Layer " << i << " Couldn't Set to Forward!" << "\n"; + std::clog << "ConnectLayers: Hidden Layer " << i << " Couldn't Set to Forward!" << "\n"; return false; } - std::clog << "Call ConnectLayers: Hidden Layers are Set to Forward Successfully!" << "\n"; + std::clog << "ConnectLayers: Hidden Layers are Set to Forward Successfully!" << "\n"; if(!(hiddenLayers + hiddenSize - 1) -> SetForward(output)) { - std::clog << "Call ConnectLayers: Output Couldn't Set to Forward!" << "\n"; + std::clog << "ConnectLayers: Output Couldn't Set to Forward!" << "\n"; return false; } - std::clog << "Call ConnectLayers: Output is Set to Forward Successfully!" << "\n"; + std::clog << "ConnectLayers: Output is Set to Forward Successfully!" << "\n"; return output -> SetForward(NULL); } @@ -566,54 +628,56 @@ float RandomFloat(int min, int max) void NeuralNetwork::FireNetwork() { // input -> FireLayer(); - // std::clog << "Call FireNetwork: Input Fired!" << "\n"; + // std::clog << "\n" << "FireNetwork: Input Fired!" << "\n"; for (int i = 0; i < hiddenSize; i++) { (hiddenLayers + i) -> FireLayer(); - std::clog << "Call FireNetwork: Hidden Layer " << i << " Fired!" << "\n"; + std::clog << "FireNetwork: Hidden Layer " << i << " Fired!" << "\n"; } output -> FireLayer(); - std::clog << "Call FireNetwork: Output Fired!" << "\n"; + std::clog << "FireNetwork: Output Fired!" << "\n"; } void NeuralNetwork::SetInput(int index, float value) { if(!input) { - std::clog << "Call SetInput: There's no Input Layer Set!" << "\n"; + std::clog << "\n" << "SetInput: There's no Input Layer Set!" << "\n"; return; } - std::clog << "Call SetInput -> Input SetValue: SetValue(" << index << ", " << value << ")!" << "\n"; + std::clog << "\n" << "SetInput -> Input SetValue: SetValue(" << index << ", " << value << ")!" << "\n"; input -> SetValue(index, value); } void NeuralNetwork::RandomizeNetworkValues() { - std::clog << "Call RandomizeNetworkValues: Input Sinapses Are Getting Randomized!" << "\n"; + std::clog << "\n" << "RandomizeNetworkValues: Input Sinapses Are Getting Randomized!" << "\n"; input -> RandomizeSinapsValues(); for (int i = 0; i < hiddenSize; i++) { - std::clog << "Call RandomizeNetworkValues: Hidden Layer " << i << " Sinapses Are Getting Randomized!" << "\n"; + std::clog << "RandomizeNetworkValues: Hidden Layer " << i << " Sinapses Are Getting Randomized!" << "\n"; (hiddenLayers + i) -> RandomizeSinapsValues(); } - std::clog << "Call RandomizeNetworkValues: Output Sinapses Are Getting Randomized!" << "\n"; + std::clog << "RandomizeNetworkValues: Output Sinapses Are Getting Randomized!" << "\n"; output -> RandomizeSinapsValues(); } float NeuralNetwork::GetOutputValue(int index) { float result = output -> GetValue(index); - std::clog << "Call GetOutputValue: " << result << "\n"; + 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); @@ -627,10 +691,21 @@ int main(int argc, char const *argv[]) network.RandomizeNetworkValues(); std::cout << "m2\n"; - // network.SetInput(0, 1); + network.SetInput(0, 1); std::cout << "m3\n"; - // network.FireNetwork(); - // std::cout << network.GetOutputValue(0) << "\n"; + 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"; return 0; }