edit chatbot and core

Xenith/core.cpp

@@ -1,82 +1,63 @@
 #include "core.h"
+#include <cmath>
+#include <cstdlib>
 
-NeuralNetwork::NeuralNetwork(LayerStructure_t layers[], int count) {
-    numLayers = count;
-    for (int i = 0; i < count; i++) {
-        layerSizes.push_back(layers[i].size);
-    }
-
-    // Инициализация весов случайными числами
+NeuralNetwork::NeuralNetwork(LayerStructure_t layers[], int count) : numLayers(count) {
+    for (int i = 0; i < count; i++) sizes.push_back(layers[i].size);
     for (int i = 0; i < count - 1; i++) {
-        std::vector<std::vector<double>> layerWeights;
-        for (int j = 0; j < layerSizes[i+1]; j++) {
-            std::vector<double> nodeWeights;
-            for (int k = 0; k < layerSizes[i]; k++) {
-                nodeWeights.push_back(((double)rand() / RAND_MAX) * 2 - 1);
-            }
-            layerWeights.push_back(nodeWeights);
+        std::vector<std::vector<double>> layerW;
+        double scale = sqrt(2.0 / sizes[i]);
+        for (int j = 0; j < sizes[i+1]; j++) {
+            std::vector<double> nodeW;
+            for (int k = 0; k < sizes[i]; k++) 
+                nodeW.push_back(((double)rand()/RAND_MAX * 2 - 1) * scale);
+            layerW.push_back(nodeW);
         }
-        weights.push_back(layerWeights);
-
-        std::vector<double> layerBiases;
-        for (int j = 0; j < layerSizes[i+1]; j++) {
-            layerBiases.push_back(((double)rand() / RAND_MAX) * 2 - 1);
-        }
-        biases.push_back(layerBiases);
+        weights.push_back(layerW);
+        biases.push_back(std::vector<double>(sizes[i+1], 0.0));
     }
 }
 
-std::vector<double> NeuralNetwork::feedForward(std::vector<double> input) {
+std::vector<double> NeuralNetwork::feedForward(const std::vector<double>& input) {
     outputs.clear();
     outputs.push_back(input);
-
-    std::vector<double> current = input;
+    std::vector<double> curr = input;
     for (int i = 0; i < numLayers - 1; i++) {
         std::vector<double> next;
-        for (int j = 0; j < layerSizes[i+1]; j++) {
+        for (int j = 0; j < sizes[i+1]; j++) {
             double sum = biases[i][j];
-            for (int k = 0; k < layerSizes[i]; k++) {
-                sum += current[k] * weights[i][j][k];
-            }
-            next.push_back(sigmoid(sum));
+            for (int k = 0; k < (int)curr.size(); k++) sum += curr[k] * weights[i][j][k];
+            next.push_back(1.0 / (1.0 + exp(-sum)));
         }
-        current = next;
-        outputs.push_back(current);
+        curr = next;
+        outputs.push_back(curr);
     }
-    return current;
+    return curr;
 }
 
-void NeuralNetwork::train(std::vector<double> input, std::vector<double> target, double lr) {
-    // 1. Прямой проход
-    feedForward(input);
-
-    // 2. Вычисление ошибок для выходного слоя
+double NeuralNetwork::train(const std::vector<double>& input, const std::vector<double>& target, double lr) {
+    std::vector<double> pred = feedForward(input);
     std::vector<std::vector<double>> errors(numLayers);
-    errors[numLayers - 1].resize(layerSizes[numLayers - 1]);
-    for (int i = 0; i < layerSizes[numLayers - 1]; i++) {
-        double output = outputs[numLayers - 1][i];
-        errors[numLayers - 1][i] = (target[i] - output) * sigmoidDerivative(output);
+    errors[numLayers-1].resize(sizes[numLayers-1]);
+    double totalErr = 0;
+    for (int i = 0; i < sizes[numLayers-1]; i++) {
+        double e = target[i] - pred[i];
+        errors[numLayers-1][i] = e * pred[i] * (1.0 - pred[i]);
+        totalErr += e * e;
     }
-
-    // 3. Обратное распространение ошибки на скрытые слои
     for (int i = numLayers - 2; i > 0; i--) {
-        errors[i].resize(layerSizes[i]);
-        for (int j = 0; j < layerSizes[i]; j++) {
-            double error = 0.0;
-            for (int k = 0; k < layerSizes[i+1]; k++) {
-                error += errors[i+1][k] * weights[i][k][j];
-            }
-            errors[i][j] = error * sigmoidDerivative(outputs[i][j]);
+        errors[i].resize(sizes[i]);
+        for (int j = 0; j < sizes[i]; j++) {
+            double e = 0;
+            for (int k = 0; k < sizes[i+1]; k++) e += errors[i+1][k] * weights[i][k][j];
+            errors[i][j] = e * outputs[i][j] * (1.0 - outputs[i][j]);
         }
     }
-
-    // 4. Обновление весов и смещений
     for (int i = 0; i < numLayers - 1; i++) {
-        for (int j = 0; j < layerSizes[i+1]; j++) {
-            for (int k = 0; k < layerSizes[i]; k++) {
-                weights[i][j][k] += lr * errors[i+1][j] * outputs[i][k];
-            }
+        for (int j = 0; j < sizes[i+1]; j++) {
+            for (int k = 0; k < sizes[i]; k++) weights[i][j][k] += lr * errors[i+1][j] * outputs[i][k];
             biases[i][j] += lr * errors[i+1][j];
         }
     }
+    return totalErr;
 }