RuntimeWarning invalid value encountered in subtract

역전파(Back-propagation)가 흐름은 알겠는데 이해가 잘되지 않아서, 증명을 하는 과정에서 갑자기 에러가 발생했다

Error : RuntimeWarning Invalid Value Encountered in Subtract

본론부터 이야기하면, 신경망 학습 과정에서 값이 너무 커져서 발생한 것이다
종종 Deep Learning에서 발생하는 문제로, 학습률이 너무 높거나 데이터가 적절히 정규화되지 않았을 때 발생할 수 있다

수정 된 코드

• 활성화 함수 : sigmoid 함수
• 손실 함수 : 평균 제곱 오차 (Mean Squared Error, MSE)

import numpy as np

# 시그모이드 함수 정의
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 시그모이드 함수의 미분 정의
def sigmoid_prime(x):
    return sigmoid(x) * (1 - sigmoid(x))

# 신경망 구조 정의
n_input = 2
n_hidden = 3
n_output = 1

# 가중치와 편향 초기화
weights_input_hidden = np.random.normal(0, scale=0.1, size=(n_input, n_hidden))
weights_hidden_output = np.random.normal(0, scale=0.1, size=(n_hidden, n_output))
biases_hidden = np.zeros(n_hidden)
biases_output = np.zeros(n_output)

# 순전파 함수 정의
def forward_propagation(input_data):
    # 은닉층에서의 값 계산
    hidden_layer_input = np.dot(input_data, weights_input_hidden) + biases_hidden
    hidden_layer_output = sigmoid(hidden_layer_input)

    # 출력층에서의 값 계산
    output_layer_input = np.dot(hidden_layer_output, weights_hidden_output) + biases_output
    output_layer_output = output_layer_input  # MSE를 위해, 활성화 함수를 통과시키지 않은 원래의 출력을 사용

    return output_layer_output

# 손실 함수 정의
def loss_function(predicted_output, actual_output):
    return np.mean((predicted_output - actual_output) ** 2)

# 역전파 함수 정의
def backpropagation(input_data, actual_output, learning_rate=0.01):
    global weights_hidden_output, biases_output

    # 은닉층에서의 값 계산
    hidden_layer_input = np.dot(input_data, weights_input_hidden) + biases_hidden
    hidden_layer_output = sigmoid(hidden_layer_input)

    # 출력층에서의 값 계산
    output_layer_input = np.dot(hidden_layer_output, weights_hidden_output) + biases_output
    predicted_output = output_layer_input  # MSE를 위해, 활성화 함수를 통과시키지 않은 원래의 출력을 사용

    # 손실 계산
    loss = loss_function(predicted_output, actual_output)

    # 출력에 대한 손실의 미분 계산
    d_loss_d_output = 2 * (predicted_output - actual_output)

    # 입력에 대한 출력의 미분 계산
    d_output_d_input = 1  # MSE의 미분은 단순히 1

    # 가중치와 편향에 대한 손실의 미분 계산
    d_loss_d_weights_hidden_output = np.dot(hidden_layer_output.T, d_loss_d_output * d_output_d_input)
    d_loss_d_biases_output = np.sum(d_loss_d_output * d_output_d_input, axis=0)

    # 가중치와 편향 업데이트
    weights_hidden_output -= learning_rate * d_loss_d_weights_hidden_output
    biases_output -= learning_rate * d_loss_d_biases_output

    return loss, weights_hidden_output, biases_output

# 학습 함수 정의
def train(input_data, actual_output, epochs=1000, learning_rate=0.01):
    # 입력 데이터 정규화
    input_data = (input_data - np.mean(input_data, axis=0)) / np.std(input_data, axis=0)

    for epoch in range(epochs):
        predicted_output = forward_propagation(input_data)
        loss = loss_function(predicted_output, actual_output)
        loss, weights, biases = backpropagation(input_data, actual_output, learning_rate)

        if epoch % 100 == 0:
            print(f'Epoch: {epoch}, Loss: {loss}, Weights: {weights}, Biases: {biases}')

# 임의의 입력 데이터 생성
input_data = np.random.rand(100, n_input)

# 임의의 실제 출력 데이터 생성
actual_output = np.random.rand(100, n_output)

# 신경망 학습
train(input_data, actual_output, learning_rate=0.001)  # 학습률 감소

부족한 점이나 잘못 된 점을 알려주시면 시정하겠습니다 :>