Desired error not necessarily achieved due to precision loss

$begingroup$

     Current function value: nan
     Iterations: 1
     Function evaluations: 18
     Gradient evaluations: 3

$endgroup$

Я получаю следующее предупреждение об использовании оптимизации SciPy fmin_bfgs() в NeuralNetwork. Все должно быть понятно и просто, по алгоритму Backpropagation.

1 Примеры обучения Feed Forward.
2 Рассчитайте срок погрешности для каждого блока.
3 Накопительный градиент (в первом примере я пропускаю термин регуляризации).

Starting Loss: 7.26524579601
Check gradient: 2.02493576268
Warning: Desired error not necessarily achieved due to precision loss.
         Current function value: 5.741300
         Iterations: 3
         Function evaluations: 104
         Gradient evaluations: 92
Trained Loss: 5.74130012926

Я только что выполнил ту же задачу с MATLAB, которая успешно выполнилась с функциями fmin для оптимизации, но не могу понять, что я упустил в реализации Python. Как видите, даже scipy.optimize.check_grad возвращает слишком большое значение.

def feed_forward(x, theta1, theta2):
    hidden_dot = np.dot(add_bias(x), np.transpose(theta1))
    hidden_p = sigmoid(hidden_dot)

    p = sigmoid(np.dot(add_bias(hidden_p), np.transpose(theta2)))
    return hidden_dot, hidden_p, p


def cost(thetas, x, y, hidden, lam):
    theta1, theta2 = get_theta_from(thetas, x, y, hidden)
    _, _, p = feed_forward(x, theta1, theta2)

    # regularization = (lam / (len(x) * 2)) * (
    #     np.sum(np.square(np.delete(theta1, 0, 1)))
    #     + np.sum(np.square(np.delete(theta2, 0, 1))))

    complete = -1 * np.dot(np.transpose(y), np.log(p)) 
               - np.dot(np.transpose(1 - y), np.log(1 - p))
    return np.sum(complete) / len(x)  # + regularization


def vector(z):
    # noinspection PyUnresolvedReferences
    return np.reshape(z, (np.shape(z)[0], 1))



def gradient(thetas, x, y, hidden, lam):
    theta1, theta2 = get_theta_from(thetas, x, y, hidden)
    hidden_dot, hidden_p, p = feed_forward(x, theta1, theta2)

    error_o = p - y
    error_h = np.multiply(np.dot(
        error_o, np.delete(theta2, 0, 1)), sigmoid_gradient(hidden_dot))

    x = add_bias(x)
    hidden_p = add_bias(hidden_p)

    theta1_grad, theta2_grad = 
        np.zeros(theta1.shape[::-1]), np.zeros(theta2.shape[::-1])
    records = y.shape[0]

    for i in range(records):
        theta1_grad = theta1_grad + np.dot(
            vector(x[i]), np.transpose(vector(error_h[i])))
        theta2_grad = theta2_grad + np.dot(
            vector(hidden_p[i]), np.transpose(vector(error_o[i])))

    theta1_grad = np.transpose(
        theta1_grad / records)  # + (lam / records * theta1)

    theta2_grad = np.transpose(
        theta2_grad / records)  # + (lam / records * theta2)

    return np.append(theta1_grad, theta2_grad)


def get_theta_shapes(x, y, hidden):
    return (hidden, x.shape[1] + 1), 
           (y.shape[1], hidden + 1)


def get_theta_from(thetas, x, y, hidden):
    t1_s, t2_s = get_theta_shapes(x, y, hidden)
    split = t1_s[0] * t1_s[1]

    theta1 = np.reshape(thetas[:split], t1_s)
    theta2 = np.reshape(thetas[split:], t2_s)
    return theta1, theta2



def train(x, y, hidden_size, lam):
    y = get_binary_y(y)

    t1_s, t2_s = get_theta_shapes(x, y, hidden_size)
    thetas = np.append(
        rand_init(t1_s[0], t1_s[1]),
        rand_init(t2_s[0], t2_s[1]))

    initial_cost = cost(thetas, x, y, hidden_size, lam)
    print("Starting Loss: " + str(initial_cost))

    check_grad1 = scipy.optimize.check_grad(
        cost, gradient, thetas, x, y, hidden_size, lam)
    print("Check gradient: " + str(check_grad1))

    trained_theta = scipy.optimize.fmin_bfgs(
        cost, thetas, fprime=gradient, args=(x, y, hidden_size, lam))

    print("Trained Loss: " +
          str(cost(trained_theta, x, y, hidden_size, lam)))

Опять же, было несколько проблем с расчетом, чтобы устранить все предупреждения и сделать успешный запуск оптимизации Scipy, то же самое с функциями оптимизации Matlab fminc. (Рабочие примеры Python можно найти в Github)

1. Обновите расчетную стоимость до правильной. Умножьте поэлементно на функцию затрат. Правильным решением по стоимости будет (со сроком регуляризации):

def cost(thetas, x, y, hidden, lam):
    theta1, theta2 = get_theta_from(thetas, x, y, hidden)
    _, _, p = feed_forward(x, theta1, theta2)

    regularization = (lam / (len(x) * 2)) * (
        np.sum(np.square(np.delete(theta1, 0, 1)))
        + np.sum(np.square(np.delete(theta2, 0, 1))))

    complete = np.nan_to_num(np.multiply((-y), np.log(
        p)) - np.multiply((1 - y), np.log(1 - p)))
    avg = np.sum(complete) / len(x)
    return avg + regularization

2. После выполнения этой операции мы получим значения nan в термине Оптимизированный Theta от Scipy. В этом случае мы выполняем np.nan_to_num выше. Примечание! Это Matlab fminc правильно работает с неожиданными числами.

3. Примените правильную регуляризацию и не забудьте удалить регуляризацию для значений смещения. Правильная функция градиента должна выглядеть так:

def gradient(thetas, x, y, hidden, lam):
    theta1, theta2 = get_theta_from(thetas, x, y, hidden)
    hidden_dot, hidden_p, p = feed_forward(x, theta1, theta2)

    error_o = p - y
    error_h = np.multiply(np.dot(
        error_o, theta2),
        sigmoid_gradient(add_bias(hidden_dot)))

    x = add_bias(x)
    error_h = np.delete(error_h, 0, 1)

    theta1_grad, theta2_grad = 
        np.zeros(theta1.shape[::-1]), np.zeros(theta2.shape[::-1])
    records = y.shape[0]

    for i in range(records):
        theta1_grad = theta1_grad + np.dot(
            vector(x[i]), np.transpose(vector(error_h[i])))
        theta2_grad = theta2_grad + np.dot(
            vector(hidden_p[i]), np.transpose(vector(error_o[i])))

    reg_theta1 = theta1.copy()
    reg_theta1[:, 0] = 0

    theta1_grad = np.transpose(
        theta1_grad / records) + ((lam / records) * reg_theta1)

    reg_theta2 = theta2.copy()
    reg_theta2[:, 0] = 0

    theta2_grad = np.transpose(
        theta2_grad / records) + ((lam / records) * reg_theta2)

    return np.append(
        theta1_grad, theta2_grad)

Просто интересно, почему вы пропустили этап регуляризации? Вы пробовали запускать программу с регуляризацией?