Простая нейронка

/// Обучение с учителем. Обучаем нейросеть прибавлять к числу 1
/// Нейросеть получает на вход от 0000 до 1111 
/// На выход подаем "правильные" то есть нужные нам данные
/// В результате после обучения нейросеть выдает на выходе значения от 0000+1 до 1111+1
/// Нейросеть создана на основании примера
/// Back propagation - алгоритм обучения по методу обратного распространения | #3 нейросети на Python
/// 10.01.2026
 
#include <iostream>
#include <vector>
#include <random>
#include <cmath>
 
//========  размеры  слоев
const int n_input = 4;
const int n_vnut0 = 10;
const int n_vnut1 = 12;
const int n_out   = 4;
 
const int var_combInp = pow(2, n_input);
///  нейроны
float N_inp[n_input] = {0};
float N_vn0[n_vnut0] = {0};
float N_vn1[n_vnut1] = {0};
float N_out[n_out]   = {0};
 
/// веса
float W_vn0[n_vnut0][n_input] = {0};
float W_vn1[n_vnut1][n_vnut0] = {0};
float W_out[n_out][n_vnut1]   = {0};
 
///bias
float bias_vn0[n_vnut0] = {0};
float bias_vn1[n_vnut1] = {0};
float bias_out[n_out]   = {0};
 
/// обучение
float target[n_out]         = {0}; // цель задаваемая нейросети
float ErrorN_Out[n_out]     = {0};
 
/// Производные сигмоиды
float SigmDxN_vn0[n_vnut0]  = {0}; // Производные сигмоиды
float SigmDxN_vn1[n_vnut1]  = {0};
float SigmDxN_out[n_out]  = {0};
/// Изменения весов
float weight_deltaOut[n_out]     = {0}; //
float weight_deltaNvn1[n_vnut1]  = {0};
float weight_deltaNvn0[n_vnut0]  = {0};
float learning_rate = 0.5f;
 
//---------------  rnd
std::mt19937 gen(325);
float rnd(float a, float b){
    std::uniform_real_distribution<float> d(a,b);
    return d(gen);
}
//void CompareBinaryResult(const vector1D& N_out, float max0, float min1) {
void CompareBinaryResult(const float* N_out, int n_out, float max0, float min1) {
    for(int i = 0; i < n_out; ++i) {
        if(N_out[i] <= max0) {  // max0 = 0.1
            std::cout << '0';
        }
        else if(N_out[i] >= min1) {  // min1 = 0.9
            std::cout << '1';
        }
        else {
            std::cout << '?';  // Результат вне ожидаемого диапазона
        }
    }
}
 
///======  Нейросеть 
/// вычисление сигмоиды
void SigmoidActivation(float* N_layer, int Nlayer_size){
    for(int i=0;i<Nlayer_size;++i)
     N_layer[i] = 1.0f/(1.0f+std::exp(-N_layer[i]));
    ///N_layer[i] = 1.0f/(1.0f+expf(-N_layer[i]));
}
/// Вычисление производной сигмоиды
void ComputeSigmDxN(float* SigmDxN, float* N_layer, int Nlayer_size){
    for(int i=0;i<Nlayer_size;++i)
    SigmDxN[i] = N_layer[i]*(1.0f-N_layer[i]);
}
 
/// вычисление содержимого следующего слоя нейронов
void ComputeLayerNeyron(float* inp_Nlayer, float* out_Nlayer, float* Weights, int inp_size, int out_size, float* bias = nullptr)
{
    for (int i = 0; i < out_size; i++) {
        out_Nlayer[i] = 0.0f;  // Обнуляем перед суммированием
        for (int j = 0; j < inp_size; j++) {
            out_Nlayer[i] += Weights[i * inp_size + j] * inp_Nlayer[j];
        }
        // Добавляем bias, если передан
        //if (bias != nullptr) {
            out_Nlayer[i] += bias[i];
       // }
    }
}
 
///  Универсальная функция для обновления весов любого слоя
void UpdateWeights(float* Weights,const int output_size,const int input_size, float* deltasW, float* inputsN, const float learning_rate) {
    for (int j = 0; j < output_size; j++) {
        for (int i = 0; i < input_size; i++) {
            int index = j * input_size + i;  // Эмуляция weights[j][i] для одномерного массива
            Weights[index] -= deltasW[j] * inputsN[i] * learning_rate;
        }
    }
}
 
/// Вычисление локальных градиентов
void ComputeLocalGradients(const float* Weights, int prev_size, int current_size,
                           float* prev_gradientsW, const float* current_gradientsW, const float* SigmDxN) {
    // Сначала вычисляем сумму без производной
    for (int i = 0; i < prev_size; i++) {
        prev_gradientsW[i] = 0.0f;  // Обнуляем
        for (int j = 0; j < current_size; j++) {
            int index = j * prev_size + i;  // Эмуляция weights[j][i]
            prev_gradientsW[i] += current_gradientsW[j] * Weights[index];
        }
        // Потом умножаем на производную активации (SigmDxN[i])
        prev_gradientsW[i] *= SigmDxN[i];
    }
}
 
///  forward прямое прохождение
/// от начала к концу inp -> 0-> 1 -> out
void forwardPass(){
/// 2. Вычисляем содержимое нейронов нулевого слоя N_vn0[i]
    ComputeLayerNeyron(N_inp, N_vn0, &W_vn0[0][0], n_input, n_vnut0, bias_vn0);
///3. применим к внутренним нейронам нулевого слоя сигмоиду:
    SigmoidActivation(N_vn0, n_vnut0);
///4. Вычисляем содержимое N_vn1[i]
    ComputeLayerNeyron(N_vn0, N_vn1, &W_vn1[0][0], n_vnut0, n_vnut1, bias_vn1);
///5. применим к внутренним нейронам первого слоя сигмоиду:
    SigmoidActivation(N_vn1, n_vnut1);
/// 6. Вычисляем содержимое нейронов выходного слоя N_out[i]
    ComputeLayerNeyron(N_vn1, N_out, &W_out[0][0], n_vnut1, n_out, bias_out);
///7. применим к нейронам выходного слоя сигмоиду:
    SigmoidActivation(N_out, n_out);
}
///   backward обратное прохождение (Backpropagation) 
/// коррекция от конца к началу! out -> 1-> 0
 
void backwardPass(){
///8.  Вычисление ошибки для каждого выходного нейрона и локального градиента weiht_deltaOut
    for(int i=0;i<n_out;++i)
     {   ErrorN_Out[i] = N_out[i]-target[i];
        ComputeSigmDxN(SigmDxN_out, N_out, n_out);
        weight_deltaOut[i]=ErrorN_Out[i]* SigmDxN_out[i];
      /// weight_deltaOut[i] = ErrorN_Out[i] * (N_out[i] * (1 - N_out[i]));
     }
/// 9. Коррекция весов выходного слоя
    UpdateWeights(&W_out[0][0], n_out, n_vnut1, weight_deltaOut, N_vn1, learning_rate);
    // Обновление bias выходного слоя
    for(int i=0;i<n_out;++i)
    bias_out[i] -= learning_rate*weight_deltaOut[i];
    ///  N_out[ii] * (1 - N_out[ii]) // производная выходного слоя
 
/// 10. Вычисление производной сигмоиды 1-ого слоя
    ComputeSigmDxN(SigmDxN_vn1,N_vn1, n_vnut1);
/// 11. вычисление локальных градиентов weiht_deltaNvn1[i]
    ComputeLocalGradients(&W_out[0][0], n_vnut1, n_out, weight_deltaNvn1, weight_deltaOut, SigmDxN_vn1);
/// 12. вычисление новых значений весов первого слоя W_vn1
    UpdateWeights(&W_vn1[0][0], n_vnut1, n_vnut0, weight_deltaNvn1, N_vn0, learning_rate);
    // Обновление bias первого скрытого слоя
    for(int i=0;i<n_vnut1;++i)
    bias_vn1[i] -= learning_rate*weight_deltaNvn1[i];
 
/// 13. вычисление значений производной нейронов 0-ого слоя N_vn0
    ComputeSigmDxN(SigmDxN_vn0, N_vn0, n_vnut0);
/// 14. вычисление значений локального градиента weiht_deltaNvn0
    ComputeLocalGradients(&W_vn1[0][0], n_vnut0, n_vnut1, weight_deltaNvn0, weight_deltaNvn1, SigmDxN_vn0);
/// 15. вычисление новых значений  W_vn0
    UpdateWeights(&W_vn0[0][0], n_vnut0, n_input, weight_deltaNvn0, N_inp, learning_rate);
    // Обновление bias нулевого скрытого слоя
    for(int i=0;i<n_vnut0;++i)
    bias_vn0[i] -= learning_rate*weight_deltaNvn0[i];
 
}
///  инициализация весов 
void initNet(){
    for(int i=0;i<n_vnut0;++i) for(int j=0;j<n_input;++j)
    W_vn0[i][j]=rnd(-0.5f,0.5f);
    for(int i=0;i<n_vnut1;++i) for(int j=0;j<n_vnut0;++j)
    W_vn1[i][j]=rnd(-0.5f,0.5f);
    for(int i=0;i<n_out;  ++i) for(int j=0;j<n_vnut1;++j)
    W_out[i][j]=rnd(-0.5f,0.5f);
 
    for(int i=0;i<n_vnut0;++i) bias_vn0[i]=rnd(-0.1f,0.1f);
    for(int i=0;i<n_vnut1;++i) bias_vn1[i]=rnd(-0.1f,0.1f);
    for(int i=0;i<n_out;  ++i) bias_out[i]=rnd(-0.1f,0.1f);
}
///  обучение на 16 примерах  (батчах)
    // входы  0000..1111
    float inp_patterns[var_combInp][n_input] = {
        {0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},
        {0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},
        {1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},
        {1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}
    };
    // выходы от 0000+1 ...1111+1
    float out_patterns[var_combInp][n_input] = {
        {0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},
        {0,1,0,1},{0,1,1,0},{0,1,1,1},{1,0,0,0},
        {1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},
        {1,1,0,1},{1,1,1,0},{1,1,1,1},{0,0,0,0}};
 
void teach16(){
 
    for(int epoch=0;epoch<1600;++epoch){
        float lossSum=0;
        for(int p=0;p<var_combInp;++p){ // батч=16
 
            for(int i=0;i<n_input;++i)
                N_inp[i]=inp_patterns[p][i];
 
            for(int i=0;i<n_out;++i)
                target[i]=out_patterns[p][i];
 
            forwardPass();// прямое прохождение
 
            // вычисление ошибки. Должна постоянно уменьшаться
            float e = 0;
            lossSum = 0; // начальное значение
 
            for(int i = 0; i < 4; ++i) {
            //e += (target[i] - N_out[i])²;  // Накапливаем e
            e += std::pow(target[i] - N_out[i], 2);
            }
            lossSum += e;
            // потеря (MSE приблизительно)
 
            backwardPass(); // обратное прохождение
 
        } // батч
        if(epoch%300==0) std::cout<<"epoch "<<epoch<<"  loss="<<lossSum/n_input<<"\n";
    } /// epoch
 
}/// Тренировкa сети окончена !!!
///===========  main 
int main(){
    initNet(); /// инициализация весов и биасов
    teach16(); /// обучение
 
    float min1=0.9;
    float max0=0.1;
 
    // проверка
    std::cout << "\n----  test  ----\n"
              << "inp   target   out      real_result \n";
 
    for(int p = 0; p < var_combInp; ++p){
        // Подаем на вход 4 числа типа float (набор 0 и 1)
        for(int i = 0; i < n_input; ++i)
            N_inp[i] = inp_patterns[p][i];
 
        // Прогоняем через сеть
        forwardPass(); // сеть натренирована backward больше не нужен
 
        // Выводим вход
        for(int i = 0; i < n_input; ++i)
            std::cout << (int)inp_patterns[p][i];
        std::cout << "   ";
 
        // Выводим цель
        for(int i = 0; i < n_input; ++i)
            std::cout << (int)out_patterns[p][i];
        std::cout << "   ";
 
        CompareBinaryResult( N_out, n_out, max0, min1); /// сравниваем результат приводим к 0 или 1 и печатаем
        std::cout << "    ";
        // Выводим реальный результат сети
        for(int i = 0; i < n_input; ++i)
            std::cout << N_out[i]<<"  ";
        std::cout << '\n';
    }
    ///Вывод данных после обучения по заданному вектору
    std::cout << std::endl;
    float numberN;
    while (true)
     {
        for (int i = 0; i < n_input; i++)
        {
            std::cout <<"Введите число от 0 до 15 в двоичном виде."<< std::endl;
            std::cout <<"Я покажу это число в двоичном виде +1."<< std::endl;
            std::cin >> numberN;
            N_inp[i] = numberN;
            std::cout << "N_inp[" << i << "]= " << N_inp[i] << std::endl;
        }
                std::cout << std::endl;
        // Прогоняем через сеть
        forwardPass(); // сеть натренирована backward больше не нужен
        /// двоичное число выданное нейросетью:
              for (int i = 0; i < n_out; i++)
                {
                    std::cout << "N_out["<<i<<"]=" <<N_out[i] << '\t'<< std::endl;
                }
        std::cout << "Повторить ввод? (y - да, любой другой символ - выход): ";
        char replyYN;
        std::cin >> replyYN;
        if (replyYN != 'Y' && replyYN != 'y') { break;}
        }
    return 0;
}

//========  размеры  слоев
const int n_input = 4;
const int n_vnut0 = 128;
const int n_vnut1 = 64;
const int n_out   = 16;
// ***********************
// выходы по числу "ножек", при входах от 0000 до 1111
    float out_patterns[var_combInp][n_input] = {
        {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0},
        ....., // ещё 13 наборов, как ножки у микросхемы (
        {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};

#include <iostream>
#include <vector>
#include <random>
#include <cmath>
#include <limits>
#include <string>
 
//========  размеры  слоев
const int n_input = 4;
const int n_vnut0 = 10;
const int n_vnut1 = 12;
const int n_out   = 4;
 
// Лучше без pow() (он возвращает double)
const int var_combInp = 1 << n_input; // 16
 
///  нейроны
float N_inp[n_input] = {0};
float N_vn0[n_vnut0] = {0};
float N_vn1[n_vnut1] = {0};
float N_out[n_out]   = {0};
 
/// веса
float W_vn0[n_vnut0][n_input] = {0};
float W_vn1[n_vnut1][n_vnut0] = {0};
float W_out[n_out][n_vnut1]   = {0};
 
///bias
float bias_vn0[n_vnut0] = {0};
float bias_vn1[n_vnut1] = {0};
float bias_out[n_out]   = {0};
 
/// обучение
float target[n_out]         = {0}; // цель задаваемая нейросети
float ErrorN_Out[n_out]     = {0};
 
/// Производные сигмоиды
float SigmDxN_vn0[n_vnut0]  = {0};
float SigmDxN_vn1[n_vnut1]  = {0};
float SigmDxN_out[n_out]    = {0};
 
/// Дельты (локальные градиенты) для нейронов слоев
float weight_deltaOut[n_out]     = {0};
float weight_deltaNvn1[n_vnut1]  = {0};
float weight_deltaNvn0[n_vnut0]  = {0};
 
float learning_rate = 0.5f;
 
//---------------  rnd
std::mt19937 gen(325);
float rnd(float a, float b){
    std::uniform_real_distribution<float> d(a,b);
    return d(gen);
}
 
// Печать бинарного результата по порогам
void CompareBinaryResult(const float* out, int out_size, float max0, float min1) {
    for(int i = 0; i < out_size; ++i) {
        if(out[i] <= max0) {
            std::cout << '0';
        }
        else if(out[i] >= min1) {
            std::cout << '1';
        }
        else {
            std::cout << '?';
        }
    }
}
 
///======  Нейросеть
 
// Сигмоида
inline float sigmoid(float x){
    return 1.0f/(1.0f + std::exp(-x));
}
 
/// вычисление сигмоиды для слоя
void SigmoidActivation(float* N_layer, int Nlayer_size){
    for(int i=0;i<Nlayer_size;++i)
        N_layer[i] = sigmoid(N_layer[i]);
}
 
/// Производная сигмоиды (ожидаем, что N_layer уже после сигмоиды)
void ComputeSigmDxN(float* SigmDxN, const float* N_layer, int Nlayer_size){
    for(int i=0;i<Nlayer_size;++i)
        SigmDxN[i] = N_layer[i]*(1.0f - N_layer[i]);
}
 
/// вычисление следующего слоя: out = W*inp + bias
void ComputeLayerNeyron(const float* inp_Nlayer, float* out_Nlayer,
                        const float* Weights, int inp_size, int out_size,
                        const float* bias)
{
    for (int i = 0; i < out_size; i++) {
        float s = 0.0f;
        for (int j = 0; j < inp_size; j++) {
            s += Weights[i * inp_size + j] * inp_Nlayer[j];
        }
        // bias обязателен (мы всегда его передаем)
        s += bias[i];
        out_Nlayer[i] = s;
    }
}
 
/// Обновление весов: W -= lr * delta[j] * input[i]
void UpdateWeights(float* Weights, int output_size, int input_size,
                   const float* deltas, const float* inputs, float lr)
{
    for (int j = 0; j < output_size; j++) {
        float d = deltas[j];
        for (int i = 0; i < input_size; i++) {
            int index = j * input_size + i;
            Weights[index] -= d * inputs[i] * lr;
        }
    }
}
 
/// ComputeLocalGradients: delta_prev[i] = (sum_j delta_cur[j] * W_cur[j][i]) * SigmDx_prev[i]
void ComputeLocalGradients(const float* Weights, int prev_size, int current_size,
                           float* prev_deltas, const float* current_deltas,
                           const float* SigmDx_prev)
{
    for (int i = 0; i < prev_size; i++) {
        float s = 0.0f;
        for (int j = 0; j < current_size; j++) {
            int index = j * prev_size + i; // W[j][i]
            s += current_deltas[j] * Weights[index];
        }
        prev_deltas[i] = s * SigmDx_prev[i];
    }
}
 
/// forward
void forwardPass(){
    ComputeLayerNeyron(N_inp, N_vn0, &W_vn0[0][0], n_input, n_vnut0, bias_vn0);
    SigmoidActivation(N_vn0, n_vnut0);
 
    ComputeLayerNeyron(N_vn0, N_vn1, &W_vn1[0][0], n_vnut0, n_vnut1, bias_vn1);
    SigmoidActivation(N_vn1, n_vnut1);
 
    ComputeLayerNeyron(N_vn1, N_out, &W_out[0][0], n_vnut1, n_out, bias_out);
    SigmoidActivation(N_out, n_out);
}
 
/// backward
void backwardPass(){
    // 1) delta для выхода
    ComputeSigmDxN(SigmDxN_out, N_out, n_out);
    for(int i=0;i<n_out;++i){
        ErrorN_Out[i] = N_out[i] - target[i];
        weight_deltaOut[i] = ErrorN_Out[i] * SigmDxN_out[i];
    }
 
    // 2) обновляем W_out и bias_out
    UpdateWeights(&W_out[0][0], n_out, n_vnut1, weight_deltaOut, N_vn1, learning_rate);
    for(int i=0;i<n_out;++i)
        bias_out[i] -= learning_rate * weight_deltaOut[i];
 
    // 3) delta для vn1
    ComputeSigmDxN(SigmDxN_vn1, N_vn1, n_vnut1);
    ComputeLocalGradients(&W_out[0][0], n_vnut1, n_out, weight_deltaNvn1, weight_deltaOut, SigmDxN_vn1);
 
    // 4) обновляем W_vn1 и bias_vn1
    UpdateWeights(&W_vn1[0][0], n_vnut1, n_vnut0, weight_deltaNvn1, N_vn0, learning_rate);
    for(int i=0;i<n_vnut1;++i)
        bias_vn1[i] -= learning_rate * weight_deltaNvn1[i];
 
    // 5) delta для vn0
    ComputeSigmDxN(SigmDxN_vn0, N_vn0, n_vnut0);
    ComputeLocalGradients(&W_vn1[0][0], n_vnut0, n_vnut1, weight_deltaNvn0, weight_deltaNvn1, SigmDxN_vn0);
 
    // 6) обновляем W_vn0 и bias_vn0
    UpdateWeights(&W_vn0[0][0], n_vnut0, n_input, weight_deltaNvn0, N_inp, learning_rate);
    for(int i=0;i<n_vnut0;++i)
        bias_vn0[i] -= learning_rate * weight_deltaNvn0[i];
}
 
/// инициализация весов
void initNet(){
    for(int i=0;i<n_vnut0;++i) for(int j=0;j<n_input;++j)
        W_vn0[i][j]=rnd(-0.5f,0.5f);
    for(int i=0;i<n_vnut1;++i) for(int j=0;j<n_vnut0;++j)
        W_vn1[i][j]=rnd(-0.5f,0.5f);
    for(int i=0;i<n_out;  ++i) for(int j=0;j<n_vnut1;++j)
        W_out[i][j]=rnd(-0.5f,0.5f);
 
    for(int i=0;i<n_vnut0;++i) bias_vn0[i]=rnd(-0.1f,0.1f);
    for(int i=0;i<n_vnut1;++i) bias_vn1[i]=rnd(-0.1f,0.1f);
    for(int i=0;i<n_out;  ++i) bias_out[i]=rnd(-0.1f,0.1f);
}
 
///  обучение на 16 примерах
float inp_patterns[var_combInp][n_input] = {
    {0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},
    {0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},
    {1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},
    {1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}
};
 
// выходы от 0000+1 ...1111+1 (мод 16)
float out_patterns[var_combInp][n_out] = {
    {0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},
    {0,1,0,1},{0,1,1,0},{0,1,1,1},{1,0,0,0},
    {1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},
    {1,1,0,1},{1,1,1,0},{1,1,1,1},{0,0,0,0}
};
 
void teach16(){
    for(int epoch=0; epoch<1600; ++epoch){
        float lossSum = 0.0f;
 
        for(int p=0; p<var_combInp; ++p){
            for(int i=0;i<n_input;++i)
                N_inp[i]=inp_patterns[p][i];
 
            for(int i=0;i<n_out;++i)
                target[i]=out_patterns[p][i];
 
            forwardPass();
 
            // MSE по 4 выходам
            float e = 0.0f;
            for(int i = 0; i < n_out; ++i)
                e += (target[i] - N_out[i]) * (target[i] - N_out[i]);
            lossSum += e / n_out;
 
            backwardPass();
        }
 
        if(epoch % 300 == 0)
            std::cout << "epoch " << epoch << "  loss=" << lossSum / var_combInp << "\n";
    }
}
 
// Утилита: прочитать 4 бита как 0/1
bool read4bits(float* bits){
    std::cout << "Введите 4 бита (например 0 1 0 1) или строкой 0101:\n> ";
 
    std::string s;
    if(!(std::cin >> s)) return false;
 
    if(s.size() == 4 && (s.find_first_not_of("01") == std::string::npos)){
        for(int i=0;i<4;++i) bits[i] = (s[i] == '1') ? 1.0f : 0.0f;
        return true;
    }
 
    auto parseBit = [](const std::string& t, float &v)->bool{
        if(t == "0" || t == "0.0" ) { v = 0.0f; return true; }
        if(t == "1" || t == "1.0" ) { v = 1.0f; return true; }
        return false;
    };
 
    if(!parseBit(s, bits[0])) return false;
    for(int i=1;i<4;++i){
        std::string t;
        if(!(std::cin >> t)) return false;
        if(!parseBit(t, bits[i])) return false;
    }
    return true;
}
 
int main(){
    initNet();
    teach16();
 
    float min1=0.9f;
    float max0=0.1f;
 
    std::cout << "\n----  test  ----\n"
              << "inp   target   out      real_result\n";
 
    for(int p = 0; p < var_combInp; ++p){
        for(int i = 0; i < n_input; ++i)
            N_inp[i] = inp_patterns[p][i];
 
        forwardPass();
 
        for(int i = 0; i < n_input; ++i)
            std::cout << (int)inp_patterns[p][i];
        std::cout << "   ";
 
        for(int i = 0; i < n_out; ++i)
            std::cout << (int)out_patterns[p][i];
        std::cout << "   ";
 
        CompareBinaryResult(N_out, n_out, max0, min1);
        std::cout << "    ";
 
        for(int i = 0; i < n_out; ++i)
            std::cout << N_out[i] << "  ";
        std::cout << '\n';
    }
 
    std::cout << "\n--- interactive ---\n";
    while(true){
        float bits[4];
        if(!read4bits(bits)){
            std::cout << "Некорректный ввод. Выход.\n";
            break;
        }
        for(int i=0;i<4;++i) N_inp[i] = bits[i];
 
        forwardPass();
 
        std::cout << "Binary out (thresholded): ";
        CompareBinaryResult(N_out, n_out, max0, min1);
        std::cout << "\nRaw out: ";
        for(int i=0;i<n_out;++i) std::cout << N_out[i] << (i==n_out-1?"\n":" ");
 
        std::cout << "Повторить ввод? (y - да, другой символ - выход): ";
        char replyYN;
        std::cin >> replyYN;
        if (replyYN != 'Y' && replyYN != 'y') break;
    }
 
    return 0;
}