Простая нейросеть выдает результат ~0.5

Пытаюсь реализовать простую однослойную нейронную сеть прямого распространения. Но результат, который она выдает после обучения(методом обратного распространения ошибки) стремиться к значению 0.5. Хоть после 1000 эпох обучения, хоть после 10000.

А если не обучать её, а с только что сгенерированными весами заставить принимать решение, то её ответ колебается в диапазоне от 0.5 к 1.

Вот привожу мой код без функции тренировки.

var weight_1 = randArr(2, 3),
    weight_2 = randArr(1, 2),
    learning_rate = 0.07
function randArr(rows, cols) {
    arr = [];
    for (var i = 0; i<rows; i++) {
        arr[i] = [];
        for (var j = 0; j<cols; j++) {
            arr[i][j] = Math.random();
        }
    }
    return arr;
}
function activation(x) {
    return 1 / (1 + Math.exp(-x));
}
function sumMultVector(A, B) {
    var C = 0;
    for (var i=0;i<A.length;i++) {
        C += A[i] * B[i];
    }
    return C;
}
function getWeightLayer(inputs, weight) {
    var getWeightLayer = [];
    for (var i = 0; i<weight.length; i++) {
        getWeightLayer[i] = activation(sumMultVector(inputs,weight[i]));
    }
    return getWeightLayer;
}
function predict(inputs) {
    outputs_1 =  getWeightLayer(inputs, weight_1);
    outputs_2 = getWeightLayer(outputs_1, weight_2);
    console.log(outputs_2);
}
predict([0, 1, 0]);

И какой бы предикшион я не вызвал результат будет от 0.5 до 1. Почему так получается?

Вот функция тренировки сети

function train(inputs, expected) {
      weights =  getWeightLayer(inputs, weight_1);
      weights_2 = getWeightLayer(weights, weight_2);
      predict_2 = weights_2[0];
      error_2 = predict_2 - expected;
      sigmoid_2 = predict_2 * (1 - predict_2);
      delta_2 = error_2 * sigmoid_2;
      weight_2[0][0] = weight_2[0][0] - weights_2[0] * delta_2 * learning_rate;
      weight_2[0][1] = weight_2[0][1] - weights_2[0] * delta_2 * learning_rate;
      for (var i = 0; i < 3; i++) {
              error_1 =  weight_2[0][j] * delta_2;
              sigmoid_1 = weights[j] * (1 - weights[j]);
              delta_2 = error_1 * sigmoid_1;
              weight_1[j][i] = weight_1[j][i] - inputs[i] * delta_2 * learning_rate;
      }
}

И моя проблема заключается в том, что все результаты, которые выдает этот алгоритм, близки к 0.5 и довольно случайны, независимо от того, какие аргументы я использую