From ae66cc0ff102e5466bc7241318ae915914732ab3 Mon Sep 17 00:00:00 2001
From: konard <drakonard@gmail.com>
Date: Wed, 28 Jan 2026 15:05:48 +0100
Subject: [PATCH 1/4] Initial commit with task details

Adding CLAUDE.md with task information for AI processing.
This file will be removed when the task is complete.

Issue: https://github.com/netkeep80/NNets/issues/27
---
 CLAUDE.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/CLAUDE.md b/CLAUDE.md
index 043e473..4410b36 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -5,3 +5,16 @@ Your forked repository: konard/netkeep80-NNets
 Original repository (upstream): netkeep80/NNets
 
 Proceed.
+
+---
+
+Issue to solve: https://github.com/netkeep80/NNets/issues/27
+Your prepared branch: issue-27-4afb08327bf8
+Your prepared working directory: /tmp/gh-issue-solver-1769609142300
+Your forked repository: konard/netkeep80-NNets
+Original repository (upstream): netkeep80/NNets
+
+Proceed.
+
+
+Run timestamp: 2026-01-28T14:05:48.533Z
\ No newline at end of file

From aa39e781bd7a58ffd6e2feec5f23b006f169ce02 Mon Sep 17 00:00:00 2001
From: konard <drakonard@gmail.com>
Date: Wed, 28 Jan 2026 15:10:55 +0100
Subject: [PATCH 2/4] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5?=
 =?UTF-8?q?=D0=BD=20=D0=B0=D0=BD=D0=B0=D0=BB=D0=B8=D0=B7=20=D0=BF=D1=80?=
 =?UTF-8?q?=D0=BE=D0=B5=D0=BA=D1=82=D0=B0,=20=D0=BF=D0=BB=D0=B0=D0=BD=20?=
 =?UTF-8?q?=D1=80=D0=B0=D0=B7=D0=B2=D0=B8=D1=82=D0=B8=D1=8F=20=D0=B8=20?=
 =?UTF-8?q?=D0=BE=D0=B1=D0=BD=D0=BE=D0=B2=D0=BB=D1=91=D0=BD=20README?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Создан analysis.md с подробным анализом проекта:
  - Обзор основных характеристик
  - Сильные стороны (функциональные и реализационные)
  - Слабые стороны и области для улучшения
  - Техническая оценка компонентов
  - Рекомендации по улучшению

- Создан plan.md с планом развития по направлениям:
  - Образование и исследования
  - Практические NLP-приложения
  - Интеграция с jsonRVM
  - Нейроморфные вычисления
  - Автоматизация и индустриальное применение
  - Улучшение качества проекта

- Обновлён README.md:
  - Добавлена русская версия документации
  - Добавлены ссылки на analysis.md и plan.md
  - Обновлена информация о возможностях проекта

Closes #27

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 README.md   | 345 ++++++++++++++++++++++++++++++----------------------
 analysis.md | 193 +++++++++++++++++++++++++++++
 plan.md     | 285 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 680 insertions(+), 143 deletions(-)
 create mode 100644 analysis.md
 create mode 100644 plan.md

diff --git a/README.md b/README.md
index b01ee65..5a9b20f 100644
--- a/README.md
+++ b/README.md
@@ -1,215 +1,251 @@
-# Self-Structuring Neural Network
+# NNets — Самоструктурирующаяся нейронная сеть / Self-Structuring Neural Network
 
-This repository contains a C++ implementation of a self-structuring neural network that learns by adding new neurons and connections to its architecture. It operates on the principle of minimizing the error vector's length, with training occurring in three iterative phases:
+[English version below](#english-version)
 
-1. Random Neuron Addition: Randomly adds neurons to the network to avoid getting stuck in local minima.
-2. Pseudo-Random Neuron Addition: Adds neurons with partial search, exploring a more targeted space of potential connections.
-3. Optimal Neuron Addition: Finds the optimal neuron placement and connection configuration to minimize the error vector's length.
+---
 
-## Features
+## Русская версия
 
-• Dynamic Structure: The network automatically grows its architecture by adding neurons and connections based on learning requirements.
+### Описание
 
-• Error-Driven Learning: Training is guided by the minimization of the error vector's length, which represents the difference between the network's output and the desired target values.
+NNets — это реализация самоструктурирующейся нейронной сети на языке C++, которая автоматически формирует свою архитектуру в процессе обучения. Вместо заранее определённой структуры, сеть динамически добавляет новые нейроны и связи для минимизации ошибки классификации.
 
-• Iterative Training: The training process consists of three distinct phases, each contributing to the network's learning.
+### Ключевые особенности
 
-• C++ Implementation: The project is written in C++, providing performance and control over the underlying data structures.
+- **Динамическая структура**: Сеть автоматически растёт, добавляя нейроны по мере необходимости
+- **Обучение через генерацию**: Вместо корректировки весов создаются новые нейроны с оптимальными параметрами
+- **14 алгоритмов обучения**: Полный перебор, случайный поиск, генерация тройки нейронов
+- **Многопоточность**: Параллельные версии всех основных алгоритмов
+- **SIMD-оптимизации**: Поддержка AVX и SSE для ускорения вычислений
+- **Кроссплатформенность**: Linux, Windows, macOS
+- **Сохранение и загрузка моделей**: Формат JSON для переносимости
+- **Дообучение**: Возможность добавления новых классов к существующей модели
 
-• Extensible Design: The code is structured to allow users to customize the neuron operations, learning algorithms, and data representations.
+### Документация
 
-## Build
+- **[analysis.md](analysis.md)** — Подробный анализ текущего состояния проекта
+- **[plan.md](plan.md)** — План развития проекта
 
-### Using CMake (Recommended)
+### Быстрый старт
 
-CMake provides cross-platform build support for Linux, macOS, and Windows.
+#### Сборка
 
 ```bash
-# Configure the build
+# Конфигурация
 cmake -B build -DCMAKE_BUILD_TYPE=Release
 
-# Build the project
+# Сборка
 cmake --build build --config Release
 ```
 
-The executable will be located in the `build` directory.
+#### Обучение
 
-### Using Visual Studio (Windows)
+```bash
+# Обучение с конфигурацией по умолчанию
+./build/NNets
+
+# Обучение с кастомной конфигурацией и сохранением модели
+./build/NNets -c configs/default.json -s model.json
 
-Open `main.sln` in Visual Studio and build the solution.
+# Обучение с автоматическим тестом
+./build/NNets -c configs/simple.json -s model.json -t
+```
 
-### Using g++ directly
+#### Использование обученной модели
 
 ```bash
-g++ -o NNets main.cpp
-```
+# Интерактивный режим
+./build/NNets -l model.json
 
-## Usage
+# Классификация одного текста
+./build/NNets -l model.json -i "time"
 
-The program supports several modes: **Training**, **Retraining**, **Inference**, and **Verification**.
+# Проверка точности
+./build/NNets -l model.json -c configs/test.json --verify
+```
 
-### Command Line Options
+#### Дообучение
 
+```bash
+# Добавление новых классов к существующей модели
+./build/NNets -r model_v1.json -c configs/extended.json -s model_v2.json
 ```
-Usage: ./NNets [options]
 
-MODES:
-  Training mode (default): Train network and optionally save to file
-  Inference mode: Load trained network and classify inputs
-  Retraining mode: Load existing network and continue training with new data
+### Опции командной строки
 
-TRAINING OPTIONS:
-  -c, --config <file>  Load training configuration from JSON file
-  -s, --save <file>    Save trained network to JSON file after training
-  -t, --test           Run automated test after training (no interactive mode)
-  -b, --benchmark      Run benchmark to measure training speed
+```
+РЕЖИМЫ РАБОТЫ:
+  Обучение (по умолчанию): Обучение сети с нуля
+  Инференс (-l): Использование обученной модели
+  Дообучение (-r): Добавление новых классов к модели
+
+ПАРАМЕТРЫ ОБУЧЕНИЯ:
+  -c, --config <файл>  Загрузить конфигурацию из JSON файла
+  -s, --save <файл>    Сохранить обученную модель в JSON файл
+  -t, --test           Запустить автоматический тест после обучения
+  -b, --benchmark      Измерить скорость обучения
+
+ПАРАМЕТРЫ ИНФЕРЕНСА:
+  -l, --load <файл>    Загрузить модель для классификации
+  -i, --input <текст>  Классифицировать один текст и выйти
+  --verify             Проверить точность модели на данных из конфига
+
+ПАРАМЕТРЫ ПРОИЗВОДИТЕЛЬНОСТИ:
+  -j, --threads <n>    Количество потоков (0 = авто)
+  --single-thread      Отключить многопоточность
+  --no-simd            Отключить SIMD-оптимизации
+
+ДРУГОЕ:
+  -h, --help           Показать справку
+  --list-funcs         Показать список функций обучения
+```
 
-RETRAINING OPTIONS:
-  -r, --retrain <file> Load existing network and continue training (retraining mode)
-                       Combines -l (load) with training mode. Requires -c for new data.
-                       New classes in config (without output_neuron) will be trained.
+### Формат конфигурации
 
-INFERENCE OPTIONS:
-  -l, --load <file>    Load trained network from JSON file (inference mode)
-  -i, --input <text>   Classify single input text and exit (non-interactive)
-  --verify             Verify accuracy of loaded model on training config (-c required)
+```json
+{
+  "description": "Описание конфигурации",
+  "receptors": 20,
+  "classes": [
+    { "id": 0, "word": "" },
+    { "id": 1, "word": "yes" },
+    { "id": 2, "word": "no" }
+  ],
+  "generate_shifts": true,
+  "funcs": ["triplet_parallel"]
+}
+```
 
-PERFORMANCE OPTIONS:
-  -j, --threads <n>    Number of threads to use (0 = auto, default)
-  --single-thread      Disable multithreading (use single thread)
+### Тестирование
 
-GENERAL OPTIONS:
-  -h, --help           Show help message
+```bash
+# Запуск всех тестов
+ctest --test-dir build -C Release
 
-INTERRUPTION:
-  Press Ctrl+C during training to interrupt gracefully.
-  The network will be saved if -s is specified.
-  Training can be continued later with -r option.
+# Запуск с подробным выводом
+ctest --test-dir build -C Release --output-on-failure
 ```
 
-### Training Mode
+### Лицензия
 
-Train a neural network from scratch using a configuration file:
+Проект распространяется под лицензией Unlicense. Вы можете использовать, модифицировать и распространять код без ограничений.
 
-```bash
-# Train with default configuration (built-in words: time, hour, main)
-./NNets
+---
 
-# Train with custom configuration
-./NNets -c configs/default.json
+## English Version
 
-# Train and save the network for later use
-./NNets -c configs/default.json -s model.json
+### Description
 
-# Train with automated testing (no interactive mode)
-./NNets -c configs/default.json -s model.json -t
+NNets is a C++ implementation of a self-structuring neural network that automatically builds its architecture during training. Instead of a predefined structure, the network dynamically adds new neurons and connections to minimize classification error.
 
-# Benchmark training speed
-./NNets -c configs/default.json -b
-```
+### Key Features
 
-### Inference Mode
+- **Dynamic Structure**: The network automatically grows by adding neurons as needed
+- **Learning through Generation**: Instead of adjusting weights, new neurons with optimal parameters are created
+- **14 Training Algorithms**: Exhaustive search, random search, triplet neuron generation
+- **Multithreading**: Parallel versions of all main algorithms
+- **SIMD Optimizations**: AVX and SSE support for computational acceleration
+- **Cross-platform**: Linux, Windows, macOS
+- **Model Save/Load**: JSON format for portability
+- **Retraining**: Ability to add new classes to an existing model
 
-Load a pre-trained network and classify inputs:
+### Documentation
+
+- **[analysis.md](analysis.md)** — Detailed analysis of the current project state (in Russian)
+- **[plan.md](plan.md)** — Project development plan (in Russian)
+
+### Quick Start
+
+#### Build
 
 ```bash
-# Interactive inference mode
-./NNets -l model.json
+# Configure
+cmake -B build -DCMAKE_BUILD_TYPE=Release
 
-# Classify a single text (non-interactive, for scripts/tests)
-./NNets -l model.json -i "time"
-./NNets -l model.json -i "yes"
+# Build
+cmake --build build --config Release
 ```
 
-### Retraining Mode
-
-Continue training an existing network with new classes or additional training data:
+#### Training
 
 ```bash
-# Add new classes to an existing model
-# 1. First, train initial model with classes yes/no
-./NNets -c configs/simple.json -s model_v1.json
+# Train with default configuration
+./build/NNets
 
-# 2. Create a new config with additional classes (e.g., adding "maybe")
-# 3. Retrain the model with new data
-./NNets -r model_v1.json -c configs/extended.json -s model_v2.json
+# Train with custom config and save model
+./build/NNets -c configs/default.json -s model.json
+
+# Train with automated test
+./build/NNets -c configs/simple.json -s model.json -t
 ```
 
-Retraining automatically detects which classes are already trained (have `output_neuron`) and only trains new classes. This is useful for:
-- Adding new recognition classes without retraining from scratch
-- Continuing interrupted training sessions
-- Incrementally improving the model
+#### Using a Trained Model
 
-### Verification Mode
+```bash
+# Interactive mode
+./build/NNets -l model.json
 
-Check the accuracy of a trained model on test data:
+# Classify single text
+./build/NNets -l model.json -i "time"
+
+# Verify accuracy
+./build/NNets -l model.json -c configs/test.json --verify
+```
+
+#### Retraining
 
 ```bash
-# Verify model accuracy on training data
-./NNets -l model.json -c configs/test.json --verify
+# Add new classes to an existing model
+./build/NNets -r model_v1.json -c configs/extended.json -s model_v2.json
 ```
 
-This mode loads the trained network and tests it against all samples in the configuration file, reporting accuracy statistics.
+### Command Line Options
 
-### Training Interruption
+```
+MODES:
+  Training (default): Train network from scratch
+  Inference (-l): Use trained model
+  Retraining (-r): Add new classes to model
 
-Training can be interrupted at any time by pressing Ctrl+C:
-- The first Ctrl+C requests graceful interruption (finishes current iteration)
-- The second Ctrl+C forces immediate exit
-- If `-s` option is specified, the network state is saved automatically
-- Training can be continued later using the `-r` (retrain) option
+TRAINING OPTIONS:
+  -c, --config <file>  Load configuration from JSON file
+  -s, --save <file>    Save trained model to JSON file
+  -t, --test           Run automated test after training
+  -b, --benchmark      Measure training speed
 
-```bash
-# Start long training with auto-save
-./NNets -c configs/large.json -s checkpoint.json
+INFERENCE OPTIONS:
+  -l, --load <file>    Load model for classification
+  -i, --input <text>   Classify single text and exit
+  --verify             Verify model accuracy on config data
 
-# Press Ctrl+C to interrupt...
-# Network saved to checkpoint.json
+PERFORMANCE OPTIONS:
+  -j, --threads <n>    Number of threads (0 = auto)
+  --single-thread      Disable multithreading
+  --no-simd            Disable SIMD optimizations
 
-# Continue training later
-./NNets -r checkpoint.json -c configs/large.json -s final_model.json
+OTHER:
+  -h, --help           Show help message
+  --list-funcs         List available training functions
 ```
 
-### Training Configuration Format
-
-Training configurations are JSON files that define the classes and training images:
+### Configuration Format
 
 ```json
 {
-  "description": "Example configuration",
+  "description": "Configuration description",
   "receptors": 20,
   "classes": [
     { "id": 0, "word": "" },
     { "id": 1, "word": "yes" },
     { "id": 2, "word": "no" }
   ],
-  "generate_shifts": true
-}
-```
-
-Configuration options:
-- `receptors`: Number of neural network inputs (text length)
-- `classes`: Array of classes with unique `id` and `word` to recognize
-- `generate_shifts`: If `true`, generates shifted variants of each word for robust recognition
-- `description`: Optional description of the configuration
-
-For advanced use, you can specify training images directly:
-
-```json
-{
-  "receptors": 12,
-  "images": [
-    { "word": "yes         ", "id": 1 },
-    { "word": " yes        ", "id": 1 },
-    { "word": "no          ", "id": 2 }
-  ]
+  "generate_shifts": true,
+  "funcs": ["triplet_parallel"]
 }
 ```
 
 ### Saved Network Format
 
-Trained networks are saved in JSON format:
-
 ```json
 {
   "version": "1.0",
@@ -221,8 +257,7 @@ Trained networks are saved in JSON format:
   "basis": [0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, -0.125, -0.25, -0.5, -1.0, -2.0, -4.0, -8.0],
   "classes": [
     { "id": 0, "name": "", "output_neuron": 109 },
-    { "id": 1, "name": "yes", "output_neuron": 298 },
-    { "id": 2, "name": "no", "output_neuron": 307 }
+    { "id": 1, "name": "yes", "output_neuron": 298 }
   ],
   "neurons": [
     { "i": 12, "j": 13, "op": 3 },
@@ -231,13 +266,7 @@ Trained networks are saved in JSON format:
 }
 ```
 
-Network structure:
-- `receptors`: Number of text character inputs
-- `basis`: Base values used for neuron operations
-- `classes`: Classes the network can recognize, with output neuron indices
-- `neurons`: Network structure (neuron IDs are implicit as `inputs + array_index`)
-
-## Example
+### Example Output
 
 ```
 Input word: time
@@ -252,14 +281,44 @@ Input word: hour
 1% -
 ```
 
-## License
+### Training Algorithms
+
+The network supports multiple training algorithms configurable via the `funcs` parameter:
+
+**Exhaustive Search** (deterministic):
+- `exhaustive_full` / `exhaustive_full_parallel` — Complete enumeration of all neuron pairs
+- `exhaustive_last` / `exhaustive_last_parallel` — Combine with the last created neuron
+- `combine_old_new` / `combine_old_new_parallel` — Combine old and new neurons
+
+**Random Search**:
+- `random_single` — Generate a single random neuron
+- `random_from_inputs` — Random generation based on inputs
+- `random_pair_opt` / `random_pair_opt_parallel` — Optimized pair generation
+- `random_pair_ext` / `random_pair_ext_parallel` — Extended pair generation
+
+**Triplet Generation** (recommended):
+- `triplet` / `triplet_parallel` — Create three connected neurons (A, B, C)
+
+Default: `triplet_parallel`
+
+### Testing
+
+```bash
+# Run all tests
+ctest --test-dir build -C Release
+
+# Run with verbose output
+ctest --test-dir build -C Release --output-on-failure
+```
+
+### License
 
 This project is licensed under the Unlicense. You are free to use, modify, and distribute this software for any purpose without any restrictions.
 
-## Contributing
+### Contributing
 
 Contributions are welcome! If you have any suggestions, bug reports, or feature requests, please feel free to open an issue or submit a pull request.
 
-## Disclaimer
+### Disclaimer
 
-This project is for educational and experimental purposes. It is not intended for production use or any critical applications. The network's accuracy and performance may vary depending on the dataset and learning parameters.
+This project is for educational and experimental purposes. It is not intended for production use or critical applications. The network's accuracy and performance may vary depending on the dataset and learning parameters.
diff --git a/analysis.md b/analysis.md
new file mode 100644
index 0000000..b914565
--- /dev/null
+++ b/analysis.md
@@ -0,0 +1,193 @@
+# Анализ проекта NNets: Текущее состояние и оценка
+
+## 1. Обзор проекта
+
+**NNets** — это реализация самоструктурирующейся нейронной сети на языке C++, которая автоматически создаёт свою архитектуру в процессе обучения путём добавления новых нейронов и связей. Проект представляет собой уникальный подход к машинному обучению, где структура сети не задаётся заранее, а формируется динамически на основе требований задачи.
+
+### Основные характеристики
+- **Язык**: C++17
+- **Лицензия**: Unlicense (свободная для любого использования)
+- **Платформы**: Linux, Windows, macOS
+- **Система сборки**: CMake (с поддержкой Visual Studio)
+- **CI/CD**: GitHub Actions
+
+---
+
+## 2. Сильные стороны проекта
+
+### 2.1 Функциональные преимущества
+
+#### Уникальный алгоритм обучения
+- **Самоструктурирующаяся архитектура**: Сеть автоматически определяет необходимое количество нейронов и связей, что устраняет необходимость ручного подбора архитектуры.
+- **Минимизация вектора ошибок**: Обучение основано на математически обоснованном принципе минимизации суммы квадратов ошибок.
+- **Избежание локальных минимумов**: Комбинация случайного и детерминированного поиска помогает выбраться из локальных минимумов.
+
+#### Богатый набор алгоритмов обучения
+Проект предоставляет **14 различных функций обучения**, организованных в три категории:
+
+1. **Полный перебор (exhaustive search)**:
+   - `exhaustive_full` / `exhaustive_full_parallel` — полный перебор всех пар нейронов
+   - `exhaustive_last` / `exhaustive_last_parallel` — комбинирование с последним созданным нейроном
+   - `combine_old_new` / `combine_old_new_parallel` — комбинирование старых и новых нейронов
+
+2. **Случайный поиск (random search)**:
+   - `random_single` — генерация одного случайного нейрона
+   - `random_from_inputs` — случайная генерация на основе входов
+   - `random_pair_opt` / `random_pair_opt_parallel` — оптимизированная генерация пары
+   - `random_pair_ext` / `random_pair_ext_parallel` — расширенная генерация пары
+
+3. **Генерация тройки (triplet search)** — основной метод:
+   - `triplet` / `triplet_parallel` — создание трёх связанных нейронов (A, B, C), где C объединяет A и B
+
+#### Гибкая система режимов работы
+- **Обучение**: Создание новой сети с нуля
+- **Дообучение (Retraining)**: Добавление новых классов к существующей модели
+- **Инференс**: Использование обученной модели для классификации
+- **Верификация**: Проверка точности модели на тестовых данных
+- **Бенчмарк**: Измерение производительности обучения
+
+#### Продвинутые возможности
+- **Прерывание и продолжение обучения**: Возможность остановить обучение по Ctrl+C и продолжить позже с помощью `-r` опции
+- **Конфигурация через JSON**: Гибкая настройка обучения без перекомпиляции
+- **Генерация сдвинутых образов**: Автоматическое создание вариаций входных данных для повышения робастности
+
+### 2.2 Преимущества реализации
+
+#### Качественная архитектура кода
+- **Модульность**: Функции обучения вынесены в отдельные заголовочные файлы (`learning_funcs/`)
+- **Документирование**: Код содержит подробные комментарии на русском языке
+- **Обратная совместимость**: Старые имена функций (`rod`, `rndrod`) сохранены как алиасы
+
+#### Оптимизация производительности
+- **SIMD-оптимизации**: Поддержка AVX (256-bit) и SSE (128-bit) для векторных операций
+- **Многопоточность**: Параллельные версии всех основных алгоритмов
+- **Кэширование**: Система кэширования значений нейронов для избежания повторных вычислений
+- **Early termination**: Прерывание вычислений при превышении текущего минимума ошибки
+
+#### Кроссплатформенность
+- Сборка и тестирование на Linux, Windows, macOS через GitHub Actions
+- Поддержка GCC, Clang, MSVC
+- Автоматическое определение SIMD-возможностей процессора
+
+#### Система тестирования
+- **14 автоматических тестов** через CTest
+- Тесты охватывают: классификацию, сохранение/загрузку, дообучение, SIMD, многопоточность
+- Интеграция с CI/CD
+
+#### Удобство использования
+- Подробная справка (`-h`, `--help`)
+- Информативный вывод во время работы
+- Поддержка как интерактивного, так и автоматического режимов
+
+---
+
+## 3. Слабые стороны и области для улучшения
+
+### 3.1 Функциональные ограничения
+
+#### Ограниченная область применения
+- **Только задачи классификации текста**: Текущая реализация ориентирована на распознавание коротких строк (слов)
+- **Фиксированный формат входов**: Только символьное кодирование (ASCII-коды / 256)
+- **Отсутствие работы с изображениями**: Нет поддержки многомерных входов
+
+#### Алгоритмические ограничения
+- **Только 4 базовые операции**: Сумма, разность, обратная разность, произведение
+- **Отсутствие активационных функций**: Нет ReLU, Sigmoid, Tanh и других нелинейностей
+- **Нет обратного распространения ошибки**: Обучение через генерацию новых нейронов, а не корректировку весов
+- **Нет регуляризации**: Отсутствуют механизмы предотвращения переобучения
+
+#### Масштабируемость
+- **Ограничение в 64000 нейронов** (`MAX_NEURONS`)
+- **Линейный рост потребления памяти**: Каждый нейрон хранит кэш для всех обучающих образов
+- **Квадратичная сложность полного перебора**: O(N²) для `exhaustive_full_search`
+
+### 3.2 Технические недостатки
+
+#### Устаревшие элементы кода
+- **Использование `<strstream>`**: Устаревший заголовок (deprecated в C++98, удалён в C++17)
+- **`char*` вместо `std::string`**: В некоторых местах используются C-style строки
+- **Глобальные переменные**: Большое количество глобальных переменных усложняет тестирование и расширение
+
+#### Проблемы с типизацией
+- **Использование `int` для индексов**: Потенциальные проблемы при большом количестве нейронов
+- **`float` вместо `double`**: Потеря точности при больших значениях
+
+#### Отсутствующая функциональность
+- **Нет логирования в файл**: Вывод только в консоль
+- **Нет визуализации структуры сети**: Нельзя экспортировать граф нейронов
+- **Нет метрик обучения**: Отсутствуют графики сходимости, история ошибок
+- **Нет валидационного набора**: Нет разделения на train/validation/test
+
+### 3.3 Документация и сообщество
+
+#### Недостатки документации
+- **README только на английском**: Нет русскоязычной версии основной документации
+- **Нет примеров использования API**: Документация ориентирована на командную строку
+- **Нет описания внутренней архитектуры**: Сложно разобраться в коде новым контрибьюторам
+
+#### Отсутствие экосистемы
+- **Нет пакетного менеджера**: Не опубликован в vcpkg, conan, apt
+- **Нет bindings для других языков**: Python, JavaScript и др.
+- **Нет веб-интерфейса**: Только CLI
+
+---
+
+## 4. Техническая оценка компонентов
+
+### 4.1 Основные модули
+
+| Компонент | Файл | Оценка | Комментарий |
+|-----------|------|--------|-------------|
+| Главный модуль | `main.cpp` | 7/10 | Хорошо структурирован, но слишком большой (932 строки) |
+| JSON I/O | `json_io.h` | 8/10 | Качественная реализация сериализации |
+| Генерация нейронов | `neuron_generation.h` | 7/10 | Хорошая модульность, но зависит от глобальных переменных |
+| SIMD-операции | `simd_ops.h` | 9/10 | Отличная реализация с автоматическим выбором инструкций |
+| Функции обучения | `learning_funcs/*.h` | 8/10 | Хорошо организованы, параллельные версии эффективны |
+
+### 4.2 Качество кода
+
+| Метрика | Оценка | Комментарий |
+|---------|--------|-------------|
+| Читаемость | 7/10 | Хорошие комментарии, но смешение языков (рус/англ) |
+| Модульность | 6/10 | Модули созданы, но глобальные переменные создают зависимости |
+| Тестируемость | 7/10 | Есть тесты, но нет unit-тестов отдельных функций |
+| Расширяемость | 6/10 | Добавление новых операций требует изменения нескольких файлов |
+| Производительность | 9/10 | SIMD, многопоточность, кэширование — всё на высоком уровне |
+
+---
+
+## 5. Рекомендации по улучшению
+
+### 5.1 Краткосрочные (легко реализуемые)
+
+1. **Заменить `<strstream>` на `<sstream>`** — устранение deprecation warning
+2. **Добавить русскоязычную версию README** — расширение аудитории
+3. **Создать CONTRIBUTING.md** — руководство для контрибьюторов
+4. **Добавить больше примеров конфигов** — демонстрация возможностей
+5. **Экспорт структуры сети в DOT/GraphViz** — визуализация
+
+### 5.2 Среднесрочные
+
+1. **Рефакторинг глобальных переменных** — инкапсуляция в классы
+2. **Добавление активационных функций** — расширение выразительности сети
+3. **Поддержка валидационного набора** — контроль переобучения
+4. **Логирование в файл** — анализ процесса обучения
+5. **Python bindings** — расширение аудитории пользователей
+
+### 5.3 Долгосрочные
+
+1. **Поддержка GPU (CUDA/OpenCL)** — ускорение обучения
+2. **Работа с изображениями** — расширение области применения
+3. **Веб-интерфейс** — демонстрация и обучение
+4. **Интеграция с jsonRVM** — реализация видения синтеза проектов
+5. **Публикация как библиотека** — vcpkg, conan
+
+---
+
+## 6. Заключение
+
+Проект NNets представляет собой уникальную и качественную реализацию самоструктурирующейся нейронной сети. Его сильные стороны — это оригинальный алгоритм, хорошая производительность и кроссплатформенность. Основные направления развития — расширение функциональности, улучшение документации и создание экосистемы вокруг проекта.
+
+**Общая оценка**: 7.5/10
+
+Проект имеет прочный фундамент и большой потенциал для развития в направлении практического применения в задачах машинного обучения и исследования биологически вдохновлённых алгоритмов.
diff --git a/plan.md b/plan.md
new file mode 100644
index 0000000..8672383
--- /dev/null
+++ b/plan.md
@@ -0,0 +1,285 @@
+# План развития проекта NNets
+
+## Введение
+
+Данный документ описывает перспективные направления развития проекта NNets — самоструктурирующейся нейронной сети. Направления отсортированы по потенциальной пользе для человечества и практической применимости.
+
+---
+
+## Направление 1: Образование и исследования
+
+### Описание
+Превращение NNets в образовательную платформу для изучения принципов самоорганизации в нейронных сетях и исследования биологически вдохновлённых алгоритмов.
+
+### Польза для человечества
+- Подготовка нового поколения специалистов в области ИИ
+- Демократизация знаний о нейронных сетях
+- Фундаментальные исследования принципов работы мозга
+
+### Задачи по приоритетам
+
+#### Высокий приоритет
+1. **Создание интерактивной визуализации**
+   - Веб-интерфейс для наблюдения за процессом обучения в реальном времени
+   - Визуализация графа нейронов и их связей
+   - Анимация процесса добавления новых нейронов
+   - Технологии: WebGL, D3.js, WebSocket для связи с C++ бэкендом
+
+2. **Разработка учебных материалов**
+   - Пошаговые туториалы по работе с проектом
+   - Объяснение математических основ алгоритмов
+   - Сравнение с традиционными подходами (backpropagation)
+   - Примеры исследовательских экспериментов
+
+3. **Python bindings (PyNNets)**
+   - Обёртка для использования в Jupyter Notebooks
+   - Интеграция с популярными ML-библиотеками (numpy, pandas)
+   - Поддержка визуализации через matplotlib
+
+#### Средний приоритет
+4. **Экспорт в стандартные форматы**
+   - Экспорт структуры сети в ONNX для сравнения с другими фреймворками
+   - Экспорт в GraphViz DOT для визуализации
+   - Экспорт истории обучения в CSV/JSON
+
+5. **Симулятор биологических процессов**
+   - Моделирование синаптической пластичности
+   - Имитация процессов прореживания (pruning)
+   - Исследование энергоэффективных архитектур
+
+---
+
+## Направление 2: Практические приложения NLP
+
+### Описание
+Расширение возможностей сети для решения практических задач обработки естественного языка.
+
+### Польза для человечества
+- Создание легковесных моделей для edge-устройств
+- Альтернатива ресурсоёмким трансформерам для простых задач
+- Обработка данных на устройствах без интернета
+
+### Задачи по приоритетам
+
+#### Высокий приоритет
+1. **Расширение входного формата**
+   - Поддержка UTF-8 (русский, китайский и другие языки)
+   - Эмбеддинги слов вместо посимвольного кодирования
+   - Работа с предложениями переменной длины
+
+2. **Новые типы задач**
+   - Определение языка текста
+   - Анализ тональности (sentiment analysis)
+   - Классификация спама/не-спама
+   - Определение намерения (intent classification)
+
+3. **Улучшение качества обучения**
+   - Добавление активационных функций (ReLU, Sigmoid, Tanh)
+   - Поддержка softmax для многоклассовой классификации
+   - Механизмы регуляризации (dropout-подобные)
+
+#### Средний приоритет
+4. **Инкрементальное обучение**
+   - Обучение на потоковых данных
+   - Адаптация к изменяющимся паттернам
+   - Защита от catastrophic forgetting
+
+5. **Мобильная версия**
+   - Компиляция для iOS/Android
+   - Оптимизация для ARM-процессоров
+   - Работа оффлайн
+
+---
+
+## Направление 3: Интеграция с jsonRVM
+
+### Описание
+Синтез NNets и проекта jsonRVM для создания декларативной системы управления нейронными сетями.
+
+### Польза для человечества
+- Демократизация создания ИИ-систем через декларативное программирование
+- Снижение порога входа для разработчиков
+- Создание самоадаптирующихся систем
+
+### Задачи по приоритетам
+
+#### Высокий приоритет
+1. **Создание NNets как DLL/SO модуля**
+   - Выделение ядра в отдельную библиотеку
+   - API для управления из внешнего кода
+   - Возможность загрузки в jsonRVM
+
+2. **Декларативное описание обучения**
+   - JSON-формат для описания сценариев обучения
+   - Условные правила (if error > threshold then add_neurons)
+   - Параллельное выполнение экспериментов
+
+3. **Интеграция с системой отношений**
+   - Нейроны как сущности в jsonRVM
+   - Связи как отношения
+   - Динамическое изменение структуры через правила
+
+#### Средний приоритет
+4. **Распределённое обучение**
+   - Координация через jsonRVM
+   - Федеративное обучение на нескольких узлах
+   - Обмен моделями между агентами
+
+---
+
+## Направление 4: Нейроморфные вычисления
+
+### Описание
+Адаптация алгоритмов NNets для нейроморфного оборудования и исследование энергоэффективных архитектур.
+
+### Польза для человечества
+- Снижение энергопотребления ИИ-систем
+- Развитие экологичных технологий
+- Исследование принципов работы мозга
+
+### Задачи по приоритетам
+
+#### Высокий приоритет
+1. **Оптимизация для низкого энергопотребления**
+   - Квантизация весов (8-bit, 4-bit)
+   - Разреженные структуры (sparse networks)
+   - Минимизация операций с памятью
+
+2. **Поддержка событийной модели**
+   - Spike-based вычисления
+   - Асинхронная обработка
+   - Временное кодирование
+
+#### Средний приоритет
+3. **Интеграция с нейроморфными чипами**
+   - Поддержка Intel Loihi
+   - Поддержка IBM TrueNorth
+   - Симуляция SpiNNaker
+
+4. **Исследование биологической пластичности**
+   - STDP (Spike-Timing-Dependent Plasticity)
+   - Гомеостатическая пластичность
+   - Метапластичность
+
+---
+
+## Направление 5: Автоматизация и индустриальное применение
+
+### Описание
+Адаптация NNets для промышленного использования в системах автоматизации и IoT.
+
+### Польза для человечества
+- Умные производства с минимальным потреблением ресурсов
+- Автономные системы мониторинга
+- Предиктивное обслуживание оборудования
+
+### Задачи по приоритетам
+
+#### Высокий приоритет
+1. **Обнаружение аномалий**
+   - Мониторинг показателей оборудования
+   - Детекция отклонений от нормы
+   - Раннее предупреждение о сбоях
+
+2. **Классификация сигналов**
+   - Обработка данных с датчиков
+   - Распознавание паттернов во временных рядах
+   - Классификация состояний системы
+
+#### Средний приоритет
+3. **Интеграция с SCADA/IoT**
+   - Протоколы MQTT, OPC UA
+   - Работа на edge-устройствах
+   - Минимальные требования к ресурсам
+
+4. **Адаптивное управление**
+   - Оптимизация параметров процессов
+   - Самонастраивающиеся контроллеры
+   - Обучение на историческх данных
+
+---
+
+## Направление 6: Улучшение качества проекта
+
+### Описание
+Технические улучшения для повышения надёжности, производительности и удобства использования.
+
+### Польза для человечества
+- Надёжная основа для всех остальных направлений
+- Снижение барьера для новых контрибьюторов
+- Долгосрочная поддерживаемость проекта
+
+### Задачи по приоритетам
+
+#### Высокий приоритет
+1. **Рефакторинг архитектуры**
+   - Замена глобальных переменных на классы
+   - Создание класса `NeuralNetwork` с чистым API
+   - Разделение на библиотеку и CLI-приложение
+
+2. **Улучшение тестирования**
+   - Unit-тесты для отдельных функций
+   - Property-based тесты
+   - Fuzzing для проверки робастности
+
+3. **Обновление кодовой базы**
+   - Замена deprecated заголовков
+   - Использование современных возможностей C++17/20
+   - Статический анализ (clang-tidy, cppcheck)
+
+#### Средний приоритет
+4. **Документация**
+   - Doxygen-документация API
+   - Архитектурные диаграммы
+   - Примеры кода для разработчиков
+
+5. **GPU-ускорение**
+   - CUDA для NVIDIA
+   - OpenCL для универсальности
+   - Сравнение производительности с CPU
+
+#### Низкий приоритет
+6. **Публикация как библиотека**
+   - vcpkg пакет
+   - conan пакет
+   - Debian/Ubuntu пакет
+
+---
+
+## Дорожная карта
+
+### Этап 1 (Фундамент)
+- Рефакторинг глобальных переменных
+- Python bindings
+- Визуализация структуры сети
+- Улучшение документации
+
+### Этап 2 (Расширение возможностей)
+- UTF-8 поддержка
+- Новые активационные функции
+- Интеграция с jsonRVM
+- Мобильная версия
+
+### Этап 3 (Специализация)
+- Нейроморфные оптимизации
+- GPU-ускорение
+- Промышленные приложения
+- Распределённое обучение
+
+### Этап 4 (Экосистема)
+- Веб-платформа для обучения
+- Маркетплейс моделей
+- Сообщество и документация
+- Интеграция с MLOps
+
+---
+
+## Заключение
+
+Проект NNets имеет потенциал развития в нескольких перспективных направлениях. Приоритетными являются:
+
+1. **Образование** — создание платформы для изучения принципов самоорганизации
+2. **Практические NLP-задачи** — расширение области применения
+3. **Интеграция с jsonRVM** — декларативное управление нейронными сетями
+
+Успешная реализация этих направлений позволит NNets занять уникальную нишу между исследовательскими проектами и промышленными ML-фреймворками, предлагая альтернативный подход к построению интеллектуальных систем.

From 827a059d8cbdc3dc1e645f27a855735b3ea3161f Mon Sep 17 00:00:00 2001
From: konard <drakonard@gmail.com>
Date: Wed, 28 Jan 2026 15:13:21 +0100
Subject: [PATCH 3/4] Revert "Initial commit with task details"

This reverts commit ae66cc0ff102e5466bc7241318ae915914732ab3.
---
 CLAUDE.md | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 4410b36..043e473 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -5,16 +5,3 @@ Your forked repository: konard/netkeep80-NNets
 Original repository (upstream): netkeep80/NNets
 
 Proceed.
-
----
-
-Issue to solve: https://github.com/netkeep80/NNets/issues/27
-Your prepared branch: issue-27-4afb08327bf8
-Your prepared working directory: /tmp/gh-issue-solver-1769609142300
-Your forked repository: konard/netkeep80-NNets
-Original repository (upstream): netkeep80/NNets
-
-Proceed.
-
-
-Run timestamp: 2026-01-28T14:05:48.533Z
\ No newline at end of file

From 8ec4abce2faf7bee54b45e6bd0e9b870e1c64ab0 Mon Sep 17 00:00:00 2001
From: konard <drakonard@gmail.com>
Date: Wed, 28 Jan 2026 17:03:15 +0100
Subject: [PATCH 4/4] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B0=20=D0=B4=D0=B5=D1=82=D0=B5=D1=80=D0=BC=D0=B8=D0=BD?=
 =?UTF-8?q?=D0=B8=D1=80=D0=BE=D0=B2=D0=B0=D0=BD=D0=BD=D0=B0=D1=8F=20=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B8=D1=86=D0=B8=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0=D1=86?=
 =?UTF-8?q?=D0=B8=D1=8F=20=D0=B3=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D0=B0=20=D1=81=D0=BB=D1=83=D1=87=D0=B0=D0=B9=D0=BD=D1=8B?=
 =?UTF-8?q?=D1=85=20=D1=87=D0=B8=D1=81=D0=B5=D0=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

В тестовом режиме (-t) используется фиксированный seed (42) для обеспечения
воспроизводимости результатов. В обычном режиме используется time(nullptr)
для случайной инициализации.

Это исправляет периодические сбои тестов на CI из-за недетерминированного
поведения нейросети при обучении.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 main.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/main.cpp b/main.cpp
index 0f58b67..763a3a7 100644
--- a/main.cpp
+++ b/main.cpp
@@ -589,7 +589,16 @@ int main(int argc, char* argv[])
 		}
 	}
 
-	cout << "Random seed: " << rand() << endl;
+	// Инициализация генератора случайных чисел
+	// В тестовом режиме используем фиксированный seed для воспроизводимости
+	unsigned int randomSeed;
+	if (testMode) {
+		randomSeed = 42;  // Фиксированный seed для детерминированных тестов
+	} else {
+		randomSeed = (unsigned int)time(nullptr);
+	}
+	srand(randomSeed);
+	cout << "Random seed: " << randomSeed << endl;
 
 	// Настройка многопоточности
 	if (UseMultithreading) {