Простая нейросеть XOR - Искусственный интеллект - Ответ 14139598

#include <iostream>
#include <ctime>
#include <cmath>
#include <vector>
 
class cXOR
{
public:
    cXOR()
    {
        /* Начальное рандомное заполнение весов между слоями */
        srand(time(NULL));
        for(short i = 0; i < inputCount; ++i)
            for(short j = 0; j < hiddenCount; ++j)
            {
                weightsInputHidden[i][j] =
                        static_cast<double>(((rand() % 100) / 100.0) - 0.5);
            }
        for(short i = 0; i < hiddenCount; ++i)
            for(short j = 0; j < outputCount; ++j)
            {
                weightsHiddenOutput[i][j] =
                        static_cast<double>(((rand() % 100) / 100.0) - 0.5);
            }
    }
 
    short query(short x1, short x2)
    {
        /* Входные сигналы * вес */
        double inputSignIH[hiddenCount];
        /* Заполнение входных сигналов */
        for(short i = 0; i < hiddenCount; ++i)
        {
            inputSignIH[i] = x1 * weightsInputHidden[0][i] +
                    x2 * weightsInputHidden[1][i];
        }
        /* Выходные сигналы скрытого слоя */
        double outputSignIH[hiddenCount];
        for(short i = 0; i < hiddenCount; ++i)
        {
            /* Пропускаем результат произведения через функцию активации */
            outputSignIH[i] = sigma(inputSignIH[i]);
        }
 
        /* Входные сигналы в выходной слой */
        double inputSignHO[hiddenCount];
        /* Умножаем на веса */
        for(short i = 0; i < outputCount; ++i)
        {
            inputSignHO[i] = outputSignIH[0] * weightsHiddenOutput[0][i] +
                    outputSignIH[1] * weightsHiddenOutput[1][i];
        }
        /* Если после активации >= 0.5 возвращаем 1
         * иначе 0 */
        if(sigma(inputSignHO[0]) >= 0.5)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
 
    /* Тренировка нейросети
     * 1 - ошибка
     * 0 - успех */
    bool train(unsigned int size, std::vector<int> x1, std::vector<int> x2,
            std::vector<int> answer, double learningrate)
    {
        if((size != x1.size()) || (size != x2.size()))
        {
            return 1;
        }
        else
        {
            /* Прогнать 999999 раз */
            for(long count = 0; count < 999999; ++count)
            /* Повторить столько раз, сколько различных
             * комплектов значений передано */
            for(size_t i = 0; i < size; ++i)
            {
                /* Если опрос неуспешен, то учим */
                if((query(x1[i], x2[i]) != answer[i]))
                {
                    /* Входные сигналы * вес */
                    double inputSignIH[hiddenCount];
                    /* Заполнение входных сигналов */
                    for(short inp = 0; inp < hiddenCount; ++inp)
                    {
                        inputSignIH[inp] = x1[inp] * weightsInputHidden[0][inp] +
                                x2[inp] * weightsInputHidden[1][inp];
                    }
                    /* Выходные сигналы скрытого слоя */
                    double outputSignIH[hiddenCount];
                    for(short outh = 0; outh < hiddenCount; ++outh)
                    {
                        /* Пропускаем результат произведения через функцию активации */
                        outputSignIH[outh] = sigma(inputSignIH[outh]);
                    }
 
                    /* Входные сигналы в выходной слой */
                    double inputSignHO[hiddenCount];
                    /* Умножаем на веса */
                    for(short inpo = 0; inpo < outputCount; ++inpo)
                    {
                        inputSignHO[inpo] = outputSignIH[0] * weightsHiddenOutput[0][inpo] +
                                outputSignIH[1] * weightsHiddenOutput[1][inpo];
                    }
 
                    ////////////////////////////////////////////////////////////////////
 
                    /* Настройка весов м/ду скрытым и выходными слоями */
                    for(int ho = 0; ho < hiddenCount; ++ho)
                    {
                        weightsHiddenOutput[ho][0] += -1 * -learningrate * sigma(inputSignHO[ho]) *
                                (1 - sigma(inputSignHO[ho])) * weightsHiddenOutput[ho][0];
                    }
                    /* Настройка весов м/ду входным и скрытым слоями */
                    for(int ho = 0; ho < hiddenCount; ++ho)
                        for(int io = 0; io < inputCount; ++io)
                        {
                            int temp = 0;
                            io == 0 ? temp = x1[io] : temp = x2[io];
                            weightsInputHidden[ho][io] += -1 * -learningrate * sigma(temp)
                                        * (1 - sigma(temp) * weightsInputHidden[ho][io]);
                        }
                }
                /* Иначе перейти к следующему комплекту для тренировки */
                else
                {
                    continue;
                }
            }
            return 0;
        }
    }
 
    /* Вывести на экран значения весов */
    void print()
    {
        std::cout << "IH:\n";
        for(int i = 0; i < inputCount; ++i)
        {
            for(int j = 0; j < hiddenCount; ++j)
            {
                std::cout << weightsInputHidden[i][j] << " ";
            }
            std::cout << std::endl;
        }
        std::cout << std::endl << "HO:\n";
        for(int i = 0; i < hiddenCount; ++i)
        {
            for(int j = 0; j < outputCount; ++j)
            {
                std::cout << weightsHiddenOutput[i][j] << " ";
            }
            std::cout << std::endl;
        }
    }
 
private:
    /* Количество нейронов  в каждом слое */
    const short inputCount = 2;
    const short hiddenCount = 2;
    const short outputCount = 1;
    /* Массивы, хранящие веса */
    double weightsInputHidden[2][2];
    double weightsHiddenOutput[2][1];
    /* Сигмоидная функция активации */
    double sigma(double x)
    {
        return 1 / (1 + pow(M_E, -x));
    }
};
 
 
 
 
int main()
{
    cXOR obj;
 
    std::cout << "Before train :\n"
            << "1 - 1 = " << obj.query(1, 1) << '\n'
            << "1 - 0 = " << obj.query(1, 0) << '\n'
            << "0 - 1 = " << obj.query(0, 1) << '\n'
            << "0 - 0 = " << obj.query(1, 1) << '\n';
    std::cout << "\n Weights:\n";
    obj.print();
 
    std::vector<int> x1 = {1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1};
    std::vector<int> x2 = {0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0};
    std::vector<int> ans = {1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1};
 
    std::cout << "Train...\n";
 
    for(int i = 0; i < 100; ++i)
    obj.train(x1.size(), x1, x2, ans, 0.3) == 0 ?
                (std::cout << "Sucsess train #" << i + 1 << "!\n") :
                (std::cout << "Error train\n");
 
    std::cout << "After train :\n"
            << "1 - 1 = " << obj.query(1, 1) << '\n'
            << "1 - 0 = " << obj.query(1, 0) << '\n'
            << "0 - 1 = " << obj.query(0, 1) << '\n'
            << "0 - 0 = " << obj.query(1, 1) << '\n';
    std::cout << "\n Weights:\n";
    obj.print();
    return 0;
}