Искусственные нейронные сети, вопросы по программе

#include <vcl.h>
#include <math.h>
#pragma hdrstop
#include "MainForm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TFormMain *FormMain;
//---------------------------------------------------------------------------
// Конструктор формы.
__fastcall TFormMain::TFormMain(TComponent* Owner) : TForm(Owner)
{
    // Заполнение списка эталонных образов.
    for (int i = 0; i < 10; i++)
    {
        ComboBoxSamples->Items->Append(i);
    }
 
    // Формирование подписей таблиц.
    StringGrid1->Cells[0][0] = "Нейр\\Вес";
    StringGrid2->Cells[0][0] = "Нейр\\Вес";
    StringGrid3->Cells[0][0] = "Нейр\\Вес";
    for (int i = 1; i < 51; i++)
    {
        StringGrid1->Cells[i][0] = i;
        StringGrid1->Cells[0][i] = i;
        StringGrid2->Cells[i][0] = i;
        StringGrid2->Cells[0][i] = i;
        StringGrid3->Cells[i][0] = i;
    }
    for (int i = 0; i < 10; i++)
    {
        StringGrid3->Cells[0][i + 1] = i + 1;
        StringGridOut->Cells[0][i] = i;
    }
}
//---------------------------------------------------------------------------
// Выбор примера образа из списка.
void __fastcall TFormMain::ComboBoxSamplesChange(TObject *Sender)
{
    // Подача выбранного примера из обучающей выборки на вход нейросети.
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            input[i][j] = LearningSamples[ComboBoxSamples->Text.ToInt()][i][j] == 1 ? HI : LO;
        }
    }
 
    // Вывод изображения.
    DrawGridPattern->Refresh();
    // Вывод результата.
    LabelOut->Caption = "";
}
//---------------------------------------------------------------------------
// Закрашивание точки входного образа.
void __fastcall TFormMain::DrawGridPatternDrawCell(TObject *Sender, int ACol, int ARow, TRect &Rect, TGridDrawState State)
{
  // Установка цвета точки входного образа.
  DrawGridPattern->Canvas->Brush->Color = input[ARow][ACol] == HI ? clBlue : clWhite;
  DrawGridPattern->Canvas->FillRect(Rect);
}
//---------------------------------------------------------------------------
// Выбор точки входного образа.
void __fastcall TFormMain::DrawGridPatternSelectCell(TObject *Sender, int ACol, int ARow, bool &CanSelect)
{
    // Инвертирование состояния точки входного образа.
    input[ARow][ACol] = input[ARow][ACol] == HI ? LO : HI;
    // Вывод результата.
    LabelOut->Caption = "";
}
//---------------------------------------------------------------------------
// Нажатие кнопки "Задать коэффициенты".
void __fastcall TFormMain::ButtonSetWeightsClick(TObject *Sender)
{
    // Генерация случайных весовых коэффициентов нейронов.
    RandomizeWeights();
    
    // Вывод значений весовых коэффициентов нейронов.
    PrintWeights();
 
    LabelOut->Caption = "";
    ButtonTrainNeuronet->Enabled = true;
}
//---------------------------------------------------------------------------
// Нажатие кнопки "Обучить нейросеть"
void __fastcall TFormMain::ButtonTrainNeuronetClick(TObject *Sender)
{
    // Обучение слоев нейросети сигнальным методом Хебба.
    SignalHebbianLearning();
    // Вывод значений весовых коэффициентов нейронов слоев.
    PrintWeights();
    // Вывод результата.
    LabelOut->Caption = "";
 
    ButtonTrainPerceptron->Enabled = true;
}
//---------------------------------------------------------------------------
// Нажатие кнопки "Обучить персептрон".
void __fastcall TFormMain::ButtonTrainPerceptronClick(TObject *Sender)
{
    // Обучение персептрона.
    PerceptronBasedLearning();
    // Вывод значений весовых коэффициентов нейронов слоев.
    PrintWeights();
    // Вывод результата.
    LabelOut->Caption = "";
    ButtonRecognize->Enabled = true;
}
//---------------------------------------------------------------------------
// Нажатие кнопки "Распознать образ".
void __fastcall TFormMain::ButtonRecognizeClick(TObject *Sender)
{
    // Результат распознавания образа.
    int result;
    // Максимальное значение выхода персептрона (инициализируется минимальным).
    double max = -1;
    // Распространение сигналов по слоям нейросети.
    Propagate();
    // Классификация персептроном выходных сигналов последнего слоя.
    Classificate();
    // Вывод значений выходов персептрона.
    PrintOut();
    // Поиск среди выходов персептрона элемента с максимальным значением.
    for (int i = 0; i < 10; i++)
    {
        if (max < outP[i])
        {
            max = outP[i];
            result = i;
        }
    }
 
    // Вывод результата.
    LabelOut->Caption = result;
}
//---------------------------------------------------------------------------
// Вывод значений весовых коэффициентов нейронов.
void __fastcall TFormMain::PrintWeights()
{
    // Вывод значений весовых коэффициентов нейронов слоев.
    for (int i = 0; i < 50; i++)
    {
        for (int j = 0; j < 50; j++)
        {
            StringGrid1->Cells[j + 1][i + 1] = weight[0][i][j];
        }
    }
    for (int i = 0; i < 50; i++)
    {
        for (int j = 0; j < 50; j++)
        {
            StringGrid2->Cells[j + 1][i + 1] = weight[1][i][j];
        }
    }
    
    // Вывод значений весовых коэффициентов нейронов персептрона.
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 50; j++)
        {
            StringGrid3->Cells[j + 1][i + 1] = weightP[i][j];
        }
    }
}
//---------------------------------------------------------------------------
// Вывод значений выходов персептрона.
void __fastcall TFormMain::PrintOut()
{
    // Вывод выходов нейросети.
    for (int i = 0; i < 10; i++)
    {
        StringGridOut->Cells[1][i] = outP[i];
    }
}
//---------------------------------------------------------------------------
// Генерация случайных весовых коэффициентов нейронов.
void __fastcall TFormMain::RandomizeWeights()
{
    // Верхняя граница диапазона.
    double boundUpper = 1.0;
    // Нижняя граница диапазона.
    double boundLower = -1.0;
 
    // Генерация псевдослучайных весовых коэффициентов нейронов слоев.
    for (int n = 0; n < 2; n++)
    {
        for (int i = 0; i < 50; i++)
        {
            for (int j = 0; j < 50; j++)
            {
                weight[n][i][j] = (double)rand() / (RAND_MAX) * (boundUpper - boundLower) + boundLower;
            }
        }
    }
 
    // Генерация псевдослучайных весовых коэффициентов нейронов персептрона.
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 50; j++)
        {
            weightP[i][j] = (double)rand() / (RAND_MAX) * (boundUpper - boundLower) + boundLower;
        }
    }
}
//---------------------------------------------------------------------------
// Распространение сигналов по слоям нейросети.
void __fastcall TFormMain::Propagate()
{
    // Перебор нейронов 1-го слоя.
    for (int i = 0; i < 50; i++)
    {
        // Взвешенная сумма входов нейрона.
        double sum = 0;
 
        // Перебор входов и весов нейрона.
        for (int j = 0; j < 50; j++)
        {
            // Вычисление взвешенной суммы входов нейрона.
            sum += input[j / 5][j % 5] * weight[0][i][j];
        }
 
        // Полулинейная активационная функция.
        if (sum > 0)
        {
            out[0][i] = kappa * sum;
        }
        else
        {
            out[0][i] = 0;
        }
    }
    // Перебор нейронов 2-го слоя.
    for (int i = 0; i < 50; i++)
    {
        // Взвешенная сумма входов нейрона.
        double sum = 0;
 
        // Перебор входов и весов нейрона.
        for (int j = 0; j < 50; j++)
        {
            // Вычисление взвешенной суммы входов нейрона.
            sum += out[0][j] * weight[1][i][j];
        }
 
        // Полулинейная активационная функция.
        if (sum > 0)
        {
            out[1][i] = kappa * sum;
        }
        else
        {
            out[1][i] = 0;
        }
    }
}
//---------------------------------------------------------------------------
// Классификация выходных сигналов нейросети.
void __fastcall TFormMain::Classificate()
{
    // Перебор нейронов слоя.
    for (int i = 0; i < 10; i++)
    {
        // Взвешенная сумма входов нейрона.
        double sum = 0;
 
        // Перебор входов и весов нейрона.
        for (int j = 0; j < 50; j++)
        {
 
            // Вычисление взвешенной суммы входов нейрона.
            sum += out[1][j] * weightP[i][j];
        }
 
        // Логистическая активационная функция.
        outP[i] = 1 / (1 + exp(-2 * sum));
    }
}
//---------------------------------------------------------------------------
// Обучение слоев сигнальным методом Хебба.
void __fastcall TFormMain::SignalHebbianLearning()
{
    // Цикл обучения.
    for (int s = 0; s < 1000; s++)
    {
        // Номер образа из обучающей выборки.
        int num = s % 10;
 
        // Подача образа на вход нейросети.
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 5; j++)
            {
                input[i][j] = LearningSamples[num][i][j] == 1 ? HI : LO;
            }
        }
        
        // Распространение сигналов по слоям нейросети.
        Propagate();
        
        // Перебор нейронов 1-го слоя.
        for (int i = 0; i < 50; i++)
        {
            // Перебор весов нейрона.
            for (int j = 0; j < 50; j++)
            {
                // Коррекция весовых коэффициентов.
                weight[0][i][j] += alpha * input[j / 5][j % 5] * out[0][i];
            }
        }
        // Перебор нейронов 2-го слоя.
        for (int i = 0; i < 50; i++)
        {
            // Перебор весов нейрона.
            for (int j = 0; j < 50; j++)
            {
                // Коррекция весовых коэффициентов.
                weight[1][i][j] += alpha * out[0][j] * out[1][i];
            }
        }
    }
}
//---------------------------------------------------------------------------
// Обучение по алгоритму обучения однослойного персептрона.
void __fastcall TFormMain::PerceptronBasedLearning()
{
    // Признак ошибки персептрона.
    bool error;
 
    // Цикл обучения персептрона всем образам из обучающей выборки (приблизительно 100 раз для каждого образа).
    for (int s = 0; s < 1000; s++)
    {
        // Номер образа из обучающей выборки.
        int num = random(10);
 
        // Подача образа на вход нейросети.
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 5; j++)
            {
                input[i][j] = LearningSamples[num][i][j] == 1 ? HI : LO;
            }
        }
 
        // Распространение сигналов по нейросети.
        Propagate();
 
        // Цикл обучения персептрона заданному образу из обучающей выборки, пока персептрон ошибается.
        do
        {
            // Классификация выходных сигналов нейросети.
            Classificate();
 
            // Сброс признака ошибки.
            error = false;
 
            // Проверка выходов персептрона.
            for (int i = 0; i < 10; i++)
            {
                if (num == i)
                {
                    if (outP[i] < 0.7)
                        error = true;
                }
                else
                {
                    if (outP[i] > 0.3)
                        error = true;
                }
            }
 
            if (error)
            {
            // Проверка выходов персептрона.
            for (int i = 0; i < 10; i++)
            {
                // Разница между требуемым и полученным значением выхода нейрона.
                double sigma = (num == i ? 1.0 : -0.0) - outP[i];
 
                // Обучение персептрона, если разница не нулевая.
                if (sigma)
                {
                    // Установка признака ошибки.
                    error = true;
 
                    // Перебор входов и весов нейрона.
                    for (int j = 0; j < 50; j++)
                    {
                        // Коррекция весовых коэффициентов нейронов персептрона.
                        weightP[i][j] += eta * sigma * out[1][j];
                    }
                }
            }
            }
        }
        while (error);
    }
}