블로그AI/딥러닝

MLP 이해 2편: NumPy로 구현하는 순전파

2 → 2 → 1 MLP의 가중치와 편향을 NumPy 배열로 만들고, 가중치 행렬의 열 하나가 뉴런 하나가 되는 순전파 코드를 작성해 XOR 네 점을 한 번에 계산했다.

Python 3.14.8NumPy 2.5.4

이 글의 코드와 수치는 노트북으로 직접 실행해 볼 수 있다.

노트북 내려받기

글의 코드와 출력은 노트북을 위에서부터 실행하면 그대로 나온다.

가중치와 편향을 배열로 만든다

이전 글의 합성함수를 사용하는 MLP를 NumPy로 구현한다.

식
ŷ = σ( σ(xW1 + b1) W2 + b2 )

먼저 식에 나오는 파라미터를 배열로 만든다. W₁, W₂는 가중치(weight), b₁, b₂는 편향(bias)이다.

1편의 네트워크 그림에서 선 하나가 가중치 하나였다. 입력층과 은닉층 사이에는 2 × 2 = 4개, 은닉층과 출력층 사이에는 2 × 1 = 2개의 선이 있다. 층마다 가중치를 행렬 하나로, 편향을 벡터 하나로 묶는다. 이 글에서는 아래 값을 쓴다.

python
w1 = np.array([[-1.2, -1.0],
               [ 0.6,  0.9]])    # (입력 2, 은닉 뉴런 2)
b1 = np.zeros(2)                 # 은닉 뉴런 2개의 편향
w2 = np.array([[ 1.3],
               [-0.6]])          # (은닉 뉴런 2, 출력 1)
b2 = np.zeros(1)                 # 출력 뉴런의 편향
파라미터 shape 뜻
w1 (2, 2) 입력 2개 → 은닉 뉴런 2개
b1 (2,) 은닉 뉴런 2개의 편향
w2 (2, 1) 은닉 뉴런 2개 → 출력 뉴런 1개
b2 (1,) 출력 뉴런의 편향

가중치 행렬의 shape는 (들어오는 값의 수, 이 층의 뉴런 수)다. 그래서 w1의 행 수는 입력 수, 열 수는 은닉 뉴런 수다. 이 값은 학습 결과가 아니라 손으로 정한 시작값이다.1 학습하면 바뀐다.

행렬곱 한 번으로 뉴런 여러 개를 계산한다

입력 x = [x₁, x₂]를 x @ w1로 계산하면 x와 w1의 각 열을 내적한 값이 나온다.

식
w1 = [[-1.2, -1.0],     <- x1에서 나가는 가중치
      [ 0.6,  0.9]]     <- x2에서 나가는 가중치
       h1    h2         <- 열 하나가 뉴런 하나

h1의 가중합 = -1.2x1 + 0.6x2   (x와 w1의 0번 열의 내적)
h2의 가중합 = -1.0x1 + 0.9x2   (x와 w1의 1번 열의 내적)

w1의 0번 열이 은닉 뉴런 h₁의 가중치, 1번 열이 h₂의 가중치다. 뉴런 하나는 1편에서 본 대로 로지스틱 회귀 하나이고, 그 가중치가 열 하나에 들어 있다. x = [1, 1]로 행렬곱 한 번과 열마다의 내적을 비교하면 결과가 같다.

python
x = np.array([[1.0, 1.0]])
print('x @ w1          =', x @ w1)
print('x[0] @ w1[:, 0] =', round(x[0] @ w1[:, 0], 4))   # 은닉 뉴런 h1
print('x[0] @ w1[:, 1] =', round(x[0] @ w1[:, 1], 4))   # 은닉 뉴런 h2
출력
x @ w1          = [[-0.6 -0.1]]
x[0] @ w1[:, 0] = -0.6
x[0] @ w1[:, 1] = -0.1

행렬곱 한 번이 뉴런마다 따로 하던 내적을 한꺼번에 계산한다. 그래서 코드에는 “뉴런”이라는 객체가 따로 없다. 뉴런은 가중치 행렬의 열 하나이고, 층 하나의 계산은 행렬곱 한 번이다. 열과 행 중 어느 쪽이 뉴런인지는 곱하는 방향이 정한다. 이 글은 x @ w1로 곱하므로 열이다.

순전파 코드를 작성한다

입력을 넣어 예측값까지 계산하는 과정이 순전파(forward pass)다. 2 → 2 → 1 MLP는 “행렬곱 → 편향 더하기 → 시그모이드”를 층마다 한 번씩, 모두 두 번 한다. 파라미터와 이 계산을 클래스 하나로 묶는다.

python
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

class MLP:
    def __init__(self):
        self.w1 = np.array([[-1.2, -1.0],
                            [ 0.6,  0.9]])
        self.b1 = np.zeros(2)
        self.w2 = np.array([[ 1.3],
                            [-0.6]])
        self.b2 = np.zeros(1)

    def forward(self, x):
        self.x = x                             # 3편 backward()에서 다시 쓴다
        self.z1 = x @ self.w1 + self.b1        # 은닉층 가중합
        self.a1 = sigmoid(self.z1)             # 은닉층 출력
        self.z2 = self.a1 @ self.w2 + self.b2  # 출력층 가중합
        self.a2 = sigmoid(self.z2)             # 예측 확률
        return self.a2

forward()의 네 줄이 글 처음의 식을 안쪽부터 계산한다. 변수 이름의 z는 가중합(시그모이드에 들어가기 전), a는 활성화 출력(시그모이드를 지난 뒤)이고, 숫자는 층 번호다. 은닉층의 출력 a1이 출력층의 입력이 된다.

입력 (1, 1)을 넣어 본다.

python
mlp = MLP()
mlp.forward(x)
print('z1 =', mlp.z1)
print('a1 =', mlp.a1)
print('z2 =', mlp.z2)
print('a2 =', mlp.a2)
출력
z1 = [[-0.6 -0.1]]
a1 = [[0.3543 0.475 ]]
z2 = [[0.1756]]
a2 = [[0.5438]]

b1이 0이라서 z1은 위에서 계산한 x @ w1과 같다. 은닉 뉴런 두 개가 시그모이드를 거쳐 0.354와 0.475를 내고, 출력 뉴런이 이 둘을 받아 예측 확률 0.544를 낸다. 0.5보다 크므로 임계값 0.5 기준으로는 1로 분류한다. XOR에서 (1, 1)의 정답은 0이니 틀린 예측이다.

forward()는 예측값 a2만 돌려주지만, 중간값 x, z1, a1, z2도 self에 남겨 둔다. 3편의 역전파가 이 중 x와 a1을 다시 쓴다.

여러 입력을 한 번에 계산한다

입력 x는 [1.0, 1.0]이 아니라 [[1.0, 1.0]]처럼 2차원 배열로 만들었다. shape는 (1, 2)이고, 행 하나가 샘플 하나다. 출력도 (1, 1)로 행 하나다.

식
x   (1, 2) -> a2 (1, 1)

행을 늘리면 여러 샘플을 같은 코드로 한 번에 계산한다. XOR 네 점을 행 네 개로 쌓아 넣으면 출력도 행 네 개다.

python
X = np.array([[0, 0],
              [0, 1],
              [1, 0],
              [1, 1]], dtype=float)   # XOR 네 점, 행 하나가 점 하나

print('X  ', X.shape, '-> a2', mlp.forward(X).shape)
print(mlp.forward(X).ravel())
출력
X   (4, 2) -> a2 (4, 1)
[0.5866 0.6018 0.5348 0.5438]

forward()는 고치지 않았다. X @ w1은 (4, 2) @ (2, 2) = (4, 2)이고, 여기에 shape가 (2,)인 b1을 더하면 브로드캐스팅으로 행마다 같은 편향이 더해진다. 그래서 샘플이 한 개든 네 개든 같은 코드가 돈다.

입력을 1차원 [1.0, 1.0]으로 넣어도 순전파는 계산된다. 그래도 2차원으로 두는 이유는 3편의 역전파가 x.T(전치)처럼 행과 열을 바꾸는 계산을 쓰기 때문이다. 1차원 배열은 .T를 해도 모양이 그대로라 역전파 계산이 맞지 않는다.

지금 가중치로는 네 점 모두 0.5를 넘으므로 전부 1로 분류한다. 정답이 1인 두 점은 맞히고, 정답이 0인 두 점은 틀린다.

정리

  • 파라미터는 층마다 가중치 행렬 하나와 편향 벡터 하나다. 가중치 행렬의 shape는 (들어오는 값의 수, 이 층의 뉴런 수)다.
  • x @ w1로 곱하면 w1의 열 하나가 뉴런 하나다. 행렬곱 한 번이 뉴런마다의 내적을 한꺼번에 계산한다.
  • 순전파는 층마다 “행렬곱 → 편향 더하기 → 시그모이드”를 한 번씩 한다. 2 → 2 → 1 MLP는 이것을 두 번 한다.
  • 입력은 행 하나가 샘플 하나인 2차원 배열이다. 행을 늘리면 같은 코드로 여러 샘플을 한 번에 계산한다.

이 글의 forward()는 예측만 한다. 지금 가중치로는 XOR 네 점 중 두 점을 틀리는데, 가중치를 어느 쪽으로 고쳐야 하는지는 순전파만으로 알 수 없다. 그 방향을 구하는 역전파는 3편에서, 그 방향으로 가중치를 고치는 방법(업데이트)은 4편에서 다룬다. 3편에서는 입력 (1, 1), 정답 0인 한 점으로 역전파를 따라가며 self에 남겨 둔 중간값이 어디에 쓰이는지 본다.

Footnotes

  1. 실제 학습에서는 가중치를 무작위 값으로 시작하고, 층의 크기에 맞춰 범위를 정하는 방법(Xavier, He 초기화)을 쓴다. 편향은 0으로 시작하기도 한다. 이 글은 3·4편에서 같은 숫자를 따라가려고 시작값을 고정했다. 무작위로 시작하는 이유는 4편에서 본다. ↩