coursera - Neural Networks and Deep Learning - (2) hidden layer

def initialize_parameters(n_x,n_h,n_y):
    """
    신경망의 가중치(W)와 편향(b)을 초기화하는 함수

    Arguments:
    n_x -- 입력층 뉴런 개수
    n_h -- 은닉층 뉴런 개수
    n_y -- 출력층 뉴런 개수

    Returns:
    parameters -- 초기화된 파라미터 딕셔너리 (W1, b1, W2, b2)
    """
    np.random.seed(42)

    W1 = np.random.randn(n_h, n_x) * 0.01
    W2 = np.random.randn(n_y, n_h) * 0.01

    b1 = np.zeros((n_h,1))
    b2 = np.zeros((n_y,1))

    parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2}
    return parameters

def compute_loss(A2,Y):
    """
    크로스 엔트로피 손실 함수 (Cost Function) 계산

    Arguments:
    A2 -- 모델의 예측값 (shape: (1, m))
    Y -- 실제 레이블 (shape: (1, m))

    Returns:
    cost -- 손실값 (scalar)
    """

    m = Y.shape[1] # number of samples

    logprobs = np.multiply(Y, np.log(1-A2)) + np.multiply(1-Y, np.log(1-A2)) # element-wise product
    cost =  -np.sum(logprobs)/m

    cost = np.squeeze(cost)
    return cost

def backward_propagation(parameters, cache, X, Y):
    """
    신경망의 역전파 (Backward Propagation) 구현

    Arguments:
    parameters -- 신경망의 가중치 및 편향을 포함하는 딕셔너리
    cache -- 순전파에서 저장한 값들 (Z1, A1, Z2, A2)
    X -- 입력 데이터 (n_x, m)
    Y -- 실제 레이블 (n_y, m)

    Returns:
    grads -- 각 가중치 및 편향에 대한 미분 값 (Gradient) 딕셔너리
    """

    m = X.shape[1]  # 샘플 개수

    # 순전파에서 저장한 값 불러오기
    A1 = cache["A1"]
    A2 = cache["A2"]
    W2 = parameters["W2"]

    # 1️⃣ 출력층의 미분 계산
    dZ2 = A2 - Y  # (n_y, m)
    dW2 = (1 / m) * np.dot(dZ2, A1.T)  # (n_y, n_h)
    db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)  # (n_y, 1)

    # 2️⃣ 은닉층의 미분 계산
    dA1 = np.dot(W2.T, dZ2)  # (n_h, m)
    dZ1 = dA1 * (1 - np.power(A1, 2))  # (n_h, m) → tanh 미분 적용
    dW1 = (1 / m) * np.dot(dZ1, X.T)  # (n_h, n_x)
    db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)  # (n_h, 1)

    # 결과 저장
    grads = {"dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2}

    return grads

def update_parameters(parameters, grads, learning_rate):
    """
    가중치 및 편향을 경사 하강법(Gradient Descent)으로 업데이트하는 함수

    Arguments:
    parameters -- 현재 가중치 및 편향 딕셔너리 (W1, b1, W2, b2)
    grads -- 역전파를 통해 계산된 미분값 딕셔너리 (dW1, db1, dW2, db2)
    learning_rate -- 학습률 (alpha)

    Returns:
    parameters -- 업데이트된 가중치 및 편향
    """

    # 딕셔너리 복사 (원본 데이터 손상 방지)
    parameters = copy.deepcopy(parameters)

    # 업데이트 공식 적용
    parameters["W1"] -= learning_rate * grads["dW1"]
    parameters["b1"] -= learning_rate * grads["db1"]
    parameters["W2"] -= learning_rate * grads["dW2"]
    parameters["b2"] -= learning_rate * grads["db2"]

    return parameters

import numpy as np

def nn_model(X, Y, n_h, num_iterations=10000, learning_rate=0.01, print_cost=False):
    """
    신경망 모델을 학습하는 함수

    Arguments:
    X -- 입력 데이터 (features, m)
    Y -- 레이블 데이터 (1, m)
    n_h -- 은닉층 크기
    num_iterations -- 경사 하강법 반복 횟수
    learning_rate -- 학습률
    print_cost -- True일 경우 1000회 반복마다 비용 출력

    Returns:
    parameters -- 학습된 가중치 및 편향
    """

    np.random.seed(3)

    # 입력 및 출력 크기 설정
    n_x = X.shape[0]
    n_y = Y.shape[0]

    # 1. 가중치 초기화
    parameters = initialize_parameters(n_x, n_h, n_y)

    # 2. Gradient Descent 루프 실행
    for i in range(num_iterations):

        # 순전파 (Forward Propagation)
        A2, cache = forward_propagation(X, parameters)

        # 비용 (Cost) 계산
        cost = compute_cost(A2, Y)

        # 역전파 (Backward Propagation)
        grads = backward_propagation(parameters, cache, X, Y)

        # 가중치 업데이트 (Update Parameters)
        parameters = update_parameters(parameters, grads, learning_rate)

        # 비용 출력
        if print_cost and i % 1000 == 0:
            print(f"Cost after iteration {i}: {cost:.6f}")

    return parameters

plt.figure(figsize=(16, 32))
hidden_layer_sizes = [1, 2, 3, 4, 5]

for i, n_h in enumerate(hidden_layer_sizes):
    plt.subplot(5, 2, i+1)
    plt.title(f'Hidden Layer of size {n_h}')

    # 모델 학습
    parameters = nn_model(X, Y, n_h=n_h, num_iterations=5000, learning_rate=0.01)

    # 결정 경계 시각화
    plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)

    # 정확도 평가
    predictions = predict(parameters, X)
    accuracy = float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100)

    print(f"Accuracy for {n_h} hidden units: {accuracy:.2f}%")