Обучение персептрона операции XOR без алгоритма обратного распространения ошибки?

Нашел в видеоурок по тому, как создать многослойный персептрон на Java.
Сеть работает, но вот вместо вычисления обратного распространения ошибки используется такой алгоритм:

// от ожидаемого значения answers вычитаем выходное значение персептрона  outer
double lErr = answers[p] - outer; 
// для изменения веса добавляется коэффициент обучения (0,1), умноженный на ошибку 
// и умноженный на значения входного сигнала, но как я понял, то это только для того чтобы проверить активный ли нейрон
wEH[i][j] += 0.1 * err[j] * enters[i];


Так вот вопрос: почему используется именно этот алгоритм ?
И в каких случаях можно использовать его, а в каких метод обратного распространения ошибки?

Весь код:

class MultiLayerPerceptron {

    double[] enters;
    double[] hidden;
    double outer;
    double[][] wEH;
    double[] wHO;
    double[][] patterns = {
            {0, 0}, {1, 0}, {0, 1}, {1, 1}
    };
    double[] answers = {0, 1, 1, 0};

    public MultiLayerPerceptron() {
        enters = new double[patterns[0].length];
        hidden = new double[2];
        wEH = new double[enters.length][hidden.length];
        wHO = new double[hidden.length];

        initWeights();
        study();
        for (int p = 0; p < patterns.length; p++) {
            for (int i = 0; i < enters.length; i++)
                enters[i] = patterns[p][i];

            countOuter();
            System.out.println(outer);
        }

    }

    public void initWeights() {
        for (int i = 0; i < enters.length; i++) {
            for (int j = 0; j < wEH.length; j++) {
                wEH[i][j] = Math.random() * 0.2 + 0.1;
            }
        }
        for (int i = 0; i < wHO.length; i++)
            wHO[i] = 0.3; // Math.random() * 0.2 + 0.1;
    }

    public void countOuter() {
        for (int i = 0; i < hidden.length; i++) {
            hidden[i] = 0;
            for (int j = 0; j < enters.length; j++) {
                hidden[i] += enters[j] * wEH[j][i];
            }
            if (hidden[i] > 0.5) hidden[i] = 1;
            else hidden[i] = 0;
        }
        outer = 0;
        for (int i = 0; i < hidden.length; i++) {
            outer += hidden[i] * wHO[i];
        }
        if (outer > 0.5) outer = 1;
        else outer = 0;
    }

    public int study() {
        double[] err = new double[hidden.length];
        double gError = 0;
        int iterations = 0;

        do {
            gError = 0;
            iterations++;
            for (int p = 0; p < patterns.length; p++) {
                for (int i = 0; i < enters.length; i++)
                    enters[i] = patterns[p][i];

                countOuter();

                double lErr = answers[p] - outer;
                gError += Math.abs(lErr);

                for (int i = 0; i < hidden.length; i++)
                    err[i] = lErr * wHO[i];
                for (int i = 0; i < enters.length; i++) {
                    for (int j = 0; j < hidden.length; j++) {
                        wEH[i][j] += 0.1 * err[j] * enters[i];

                    }
                }
                for (int i = 0; i < hidden.length; i++)
                    wHO[i] += 0.1 * lErr * hidden[i];
            }
        } while (gError != 0);
        return iterations;
    }

    public static void main(String[] args){
       MultiLayerPerceptron mlp = new MultiLayerPerceptron();
       int iter = mlp.study();
        System.out.println("количество операций = "+iter);
    }
}
  • Вопрос задан
  • 73 просмотра
Пригласить эксперта
Ваш ответ на вопрос

Войдите, чтобы написать ответ

Войти через центр авторизации
Похожие вопросы
МойСклад Москва
от 140 000 до 200 000 руб.
от 70 000 до 130 000 руб.
ГРАН Software Москва
от 70 000 руб.
18 июл. 2019, в 10:14
300 руб./за проект
18 июл. 2019, в 09:39
5000 руб./за проект
18 июл. 2019, в 09:29
700 руб./в час