ls

Xenith/core.cpp

@@ -0,0 +1,82 @@
+#include "core.h"
+
+NeuralNetwork::NeuralNetwork(LayerStructure_t layers[], int count) {
+    numLayers = count;
+    for (int i = 0; i < count; i++) {
+        layerSizes.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);
+        }
+        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);
+    }
+}
+
+std::vector<double> NeuralNetwork::feedForward(std::vector<double> input) {
+    outputs.clear();
+    outputs.push_back(input);
+
+    std::vector<double> current = input;
+    for (int i = 0; i < numLayers - 1; i++) {
+        std::vector<double> next;
+        for (int j = 0; j < layerSizes[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));
+        }
+        current = next;
+        outputs.push_back(current);
+    }
+    return current;
+}
+
+void NeuralNetwork::train(std::vector<double> input, std::vector<double> target, double lr) {
+    // 1. Прямой проход
+    feedForward(input);
+
+    // 2. Вычисление ошибок для выходного слоя
+    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);
+    }
+
+    // 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]);
+        }
+    }
+
+    // 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];
+            }
+            biases[i][j] += lr * errors[i+1][j];
+        }
+    }
+}

Xenith/core.h

@@ -1,9 +1,28 @@
+#ifndef CORE_H
+#define CORE_H
 
-class NeuroEngine: {
-    private:
-        void* m_engine;
-    public:
-        NeuroEngine();
-        ~NeuroEngine();
-        void* getEngine();
-}
+#include "typedef.h"
+#include <vector>
+#include <cmath>
+#include <iostream>
+#include <cstdlib>
+
+class NeuralNetwork {
+private:
+    int numLayers;
+    std::vector<int> layerSizes;
+    std::vector<std::vector<std::vector<double>>> weights; // weights[layer][to_node][from_node]
+    std::vector<std::vector<double>> biases;             // biases[layer][node]
+    std::vector<std::vector<double>> outputs;            // Храним выходы слоев для backprop
+
+    double sigmoid(double x) { return 1.0 / (1.0 + exp(-x)); }
+    double sigmoidDerivative(double x) { return x * (1.0 - x); }
+
+public:
+    NeuralNetwork(LayerStructure_t layers[], int count);
+    
+    std::vector<double> feedForward(std::vector<double> input);
+    void train(std::vector<double> input, std::vector<double> target, double learningRate);
+};
+
+#endif

Xenith/typedef.h

@@ -0,0 +1,15 @@
+#ifndef TYPEDEF_H
+#define TYPEDEF_H
+
+#include <vector>
+
+typedef enum {
+    SIGMOID
+} FunctionActivate_t;
+
+typedef struct {
+    int size;
+    FunctionActivate_t activate;
+} LayerStructure_t;
+
+#endif