[AI] 딥러닝을 다시 처음부터.수식이 보이기 시작하는 4주 (기본기 - Andrew Ng의 Neural Networks and Deep Learning 정리)

DEEP LEARNING FUNDAMENTALS · ANDREW NG · NEURAL NETWORKS

딥러닝을 다시 처음부터.
수식이 보이기 시작하는 4주

요즘 AI Engineer의 화면에는 Transformer, RAG, Agent, MCP, vLLM 같은 단어가 가득하다. 그런데 모델 내부로 한 겹만 들어가면 아주 오래된 친구들이 다시 나타난다. Matrix Multiplication, Activation Function, Loss, Gradient, Backpropagation. 수십억 개 Parameter를 가진 LLM도 결국 이 기초 위에서 움직인다.

THE WHOLE COURSE IN FOUR ARROWS

입력을 앞으로 흘려 예측한다.
얼마나 틀렸는지 Loss를 계산한다.
틀린 책임을 뒤로 추적한다.
책임만큼 W와 b를 조금 고친다.

Andrew Ng의 Neural Networks and Deep Learning Course 1, Week 1~4는 사실 이 네 문장을 조금씩 확장하는 과정이다.

이번 편의 범위 Week 1 — Neural Network는 왜 등장했을까?
Week 2 — Logistic Regression · Loss · Gradient Descent · Derivative · Computation Graph · Vectorization
Week 3 — Hidden Layer · Activation · Backpropagation · Random Initialization
Week 4 — L-layer Deep Network · Matrix Dimension · Deep Representation · Parameter / Hyperparameter

먼저 지도를 보자: 네 가지 모델을 배우는 게 아니다

Week가 바뀔수록 완전히 새로운 알고리즘이 등장하는 것이 아니라, 같은 계산 구조가 더 큰 Network로 확장된다.

```

Week 2의 Logistic Regression을 별개의 옛날 알고리즘으로 생각하면 강의가 복잡해진다. 오히려 Hidden Layer가 없는 가장 작은 Neural Network라고 보는 편이 좋다.

Week 3에서는 그 앞에 Hidden Layer 하나를 붙인다. Week 4에서는 같은 Block을 여러 개 붙인다.

수식을 보기 전에: 기호부터 친구가 되자

Deep Learning 수식이 어려워 보이는 이유의 절반은 수학이 아니라 Notation 때문이다. 앞으로 계속 등장할 기호부터 정리하자.

기호	뜻	예시
x	입력 vector	고객의 여러 feature
y	정답	Fraud=1, Normal=0
ŷ	모델 예측	0.82
w	Weight	각 feature 영향력
b	Bias	기준점을 이동
z	Linear 계산 결과	wᵀx+b
a	Activation	g(z)
m	Training example 수	100,000건
nₓ	입력 feature 수	128개

위첨자도 규칙이 있다.
x⁽³⁾ → 세 번째 Training Example
W⁽²⁾ → 두 번째 Layer의 Weight
a₄⁽²⁾ → 두 번째 Layer, 네 번째 Neuron의 Activation

WEEK 1

Neural Network는 대체 무엇을 배우는가

Neural Network라는 이름 때문에 뇌를 정교하게 복제한 장치를 떠올리기 쉽다. Course 1에서는 훨씬 단순하게 시작하는 편이 좋다.

ONE NEURON

입력을 가중합하고 → Activation을 통과시킨다.

z = wᵀx + b  →  a = g(z)

집값 예측으로 보는 가장 작은 Network

```

학습한다는 것은 결국 실제 집값에 가까운 예측이 나오도록 w와 b를 자동으로 찾는 과정이다.

Supervised Learning: 답안지를 보면서 공부한다

입력 X                     정답 Y
────────────────────────────────────────
고객 거래 내역           → Fraud / Normal
주택 사진               → House / Not House
음성                    → Transcript
이메일                  → Spam / Not Spam

모델은 예측과 정답의 차이를 측정하고, 그 차이를 줄이는 방향으로 Parameter를 수정한다.

왜 Deep Learning이 갑자기 잘되기 시작했을까?

DATA

더 많은 데이터

디지털 서비스가 커지며 학습 가능한 데이터 규모가 커졌다.

COMPUTE

더 빠른 계산

GPU와 병렬 계산으로 훨씬 큰 Network를 학습할 수 있게 됐다.

ALGORITHM

더 좋은 알고리즘

ReLU 같은 개선은 더 깊은 Network의 학습을 현실적으로 만들었다.

Engineering Insight
Machine Learning에서는 아이디어 → 코드 → 실험 → 결과 → 수정의 Loop가 빠를수록 같은 시간에 더 많은 가설을 검증할 수 있다.

WEEK 2

Neuron 하나를 완전히 해부해보자

Week 2는 Course 1의 심장이다. Logistic Regression, Loss, Gradient Descent, Derivative, Computation Graph, Vectorization이 모두 하나의 질문을 해결하기 위해 등장한다.

컴퓨터는 어떻게 W와 b를 스스로 고칠까?

1. Binary Classification

y = 1  → Cat
y = 0  → Not Cat

64×64 RGB 이미지라면 한 장의 이미지는

nₓ = 64 × 64 × 3 = 12,288

길이 12,288짜리 입력 Vector가 된다.

2. 여러 Example은 Matrix로 쌓는다

X = [ x⁽¹⁾  x⁽²⁾  ...  x⁽ᵐ⁾ ]

X.shape = (nₓ, m)


Y = [ y⁽¹⁾  y⁽²⁾  ...  y⁽ᵐ⁾ ]

Y.shape = (1, m)

한 열(Column)이 Training Example 하나라고 기억하면 뒤의 Matrix Shape가 훨씬 쉽게 읽힌다.

3. Logistic Regression의 Forward

z = wᵀx + b

Fraud 예측 모델에 feature 세 개가 있다고 해보자.

x₁ = 거래금액          = 0.7
x₂ = 해외거래 여부      = 1.0
x₃ = 최근 이상거래 횟수 = 0.4

w₁ = 0.8
w₂ = 1.2
w₃ = 0.5

b = -0.7

z
= w₁x₁ + w₂x₂ + w₃x₃ + b

= 0.8×0.7 + 1.2×1.0 + 0.5×0.4 - 0.7

= 1.26

z=1.26만 보고 Fraud 확률을 이해하기는 어렵다. 그래서 Sigmoid를 통과시킨다.

4. Sigmoid: 아무 숫자나 0~1 사이로

σ(z) = 1 / (1 + e^-z)

a = sigmoid(1.26)
  ≈ 0.779

모델은 현재 입력에 대해 y=1일 확률을 약 77.9%로 보고 있다.

5. Loss Function: 얼마나 자신 있게 틀렸는가

L(a,y) = -[y log(a) + (1-y)log(1-a)]

무섭게 생겼지만 y=1과 y=0으로 나누면 단순하다.

정답	Loss	의미
y=1	-log(a)	a가 1에 가까울수록 Loss가 작다.
y=0	-log(1-a)	a가 0에 가까울수록 Loss가 작다.

정답이 y=1일 때 숫자로 보면 더 쉽다.

예측 a	Loss	해석
0.99	약 0.01	거의 완벽하다.
0.80	약 0.22	괜찮다.
0.50	약 0.69	모르겠다.
0.01	약 4.61	정답은 1인데 매우 자신 있게 0이라고 했다.

Cross Entropy의 중요한 특징
단순히 틀린 예측보다 틀린 답을 높은 확신으로 말하는 예측을 크게 벌준다.

6. 왜 하필 이 Loss일까?

모델이 y=1일 확률을 a라고 예측한다고 하자.

P(y=1 | x) = a
P(y=0 | x) = 1-a

두 경우를 하나의 식으로 쓰면:

P(y|x) = a^y(1-a)^1-y

y = 1:
a¹(1-a)⁰ = a

y = 0:
a⁰(1-a)¹ = 1-a

실제 데이터가 나올 확률, 즉 Likelihood를 크게 만들고 싶다. 로그를 취하고 부호를 반대로 바꾸어 최소화 문제로 만들면 Binary Cross Entropy가 나온다.

L = -[y log(a) + (1-y)log(1-a)]

7. Loss와 Cost

한 개 Example에 대한 오차가 Loss라면, Training Set 전체 Loss의 평균이 Cost다.

J(w,b) = (1/m) Σ L(a⁽ⁱ⁾, y⁽ⁱ⁾)

8. Gradient Descent: 산에서 내려가기

목표는 명확하다.

Cost J(w,b)를 작게 만드는 W와 b를 찾는다.

w := w - α · dw

w   = 현재 Parameter
dw  = Cost가 증가하는 방향과 크기
α   = Learning Rate

따라서 -dw 방향으로 이동한다.

숫자로 직접 해보자.

J(w) = (w - 3)²

dJ/dw = 2(w-3)

현재 w = 5라면:

dw = 2(5-3)
   = 4

α = 0.1

w_new
= 5 - 0.1×4
= 4.6

최적점인 3 쪽으로 조금 이동했다. 이 과정을 계속 반복하는 것이 Gradient Descent다.

9. Derivative: 입력을 살짝 움직였을 때

입력을 아주 조금 바꾸면 출력은 얼마나 움직일까?

f(a) = 3a

a = 2.000 → f(a) = 6.000
a = 2.001 → f(a) = 6.003

입력 변화  = 0.001
출력 변화  = 0.003

비율 = 3

Deep Learning에서는 이 질문을 계속 반복한다. W를 아주 조금 움직이면 Loss가 얼마나 변하는가?

10. Computation Graph: 계산의 영수증

J = 3(a + bc)

a = 3
b = 5
c = 3

u = b × c = 15
v = a + u = 18
J = 3 × v = 54

Backward에서는 반대로 책임을 추적한다.

dJ/dv = 3

dv/da = 1

따라서:

dJ/da
= dJ/dv × dv/da
= 3 × 1
= 3

그리고 u=bc이므로:

dJ/db
= dJ/du × du/db
= 3 × c
= 9

dJ/dc
= dJ/du × du/dc
= 3 × b
= 15

이게 Chain Rule의 핵심이다.
최종 결과를 한 번에 미분하는 대신 중간 경로의 미분을 차례로 곱한다.

11. 왜 dZ = A - Y일까?

Backpropagation에서 가장 마법처럼 보이는 식 중 하나다.

BACKPROP'S SURPRISINGLY SIMPLE RESULT

dZ = A - Y

Forward를 다시 쓰면:

z = wᵀx + b

a = sigmoid(z)

L = -[y log(a) + (1-y)log(1-a)]

원하는 값은:

dL/dz

Chain Rule을 쓰면:

dL/dz = (dL/da) × (da/dz)

Step 1. Loss를 a로 미분

L
= -[y log(a) + (1-y)log(1-a)]

dL/da
= -y/a + (1-y)/(1-a)

Step 2. Sigmoid를 z로 미분

da/dz = a(1-a)

Step 3. 둘을 곱한다

dL/dz

= [-y/a + (1-y)/(1-a)] × a(1-a)

= -y(1-a) + (1-y)a

= -y + ya + a - ya

= a - y

RESULT

dZ = A - Y

복잡한 Log Loss와 Sigmoid의 미분이 정리되면서 결국 예측 - 정답만 남는다.

정답 y = 1
예측 a = 0.8

dz = 0.8 - 1
   = -0.2

예측이 정답보다 작기 때문에 Parameter는 다음 예측을 더 크게 만드는 방향으로 움직인다.

12. 그러면 dw와 db는?

z=wᵀx+b였으므로:

dL/dwⱼ
= dL/dz × dz/dwⱼ

= (a-y) × xⱼ

dw = x(a-y)

Bias는 dz/db=1이므로:

db = a-y

13. Vectorization: 한 명씩 계산하지 않는다

# 느린 사고방식

for i in range(m):
    z[i] = w.T @ x[:, i] + b
    a[i] = sigmoid(z[i])

Matrix로 한꺼번에 계산하면:

Z = wᵀX + b

A = sigmoid(Z)

실제 숫자로 해보자.

X = [
  [ 1,  2, -1 ],
  [ 3,  0,  2 ]
]

X.shape = (2, 3)

w = [
  [ 0.4 ],
  [-0.2 ]
]

w.shape = (2, 1)

b = 0.1

wᵀX

첫 번째 Example:
0.4×1 + (-0.2)×3 = -0.2

두 번째:
0.4×2 + (-0.2)×0 = 0.8

세 번째:
0.4×(-1) + (-0.2)×2 = -0.8

Z = [-0.1, 0.9, -0.7]

A ≈ [0.475, 0.711, 0.332]

Vectorization의 본질
여러 Neuron과 여러 Example을 큰 Matrix/Tensor 연산으로 묶어 계산한다. 현대 GPU가 특히 잘하는 종류의 연산이다.

14. Vectorized Gradient의 Shape

A  : (1, m)
Y  : (1, m)
dZ : (1, m)

X  : (nₓ, m)

Weight Gradient는:

dw = (1/m) X dZᵀ

(nₓ, m) × (m, 1) = (nₓ, 1)

정확히 Weight Vector와 같은 Shape가 나온다.

15. Broadcasting과 Shape

Z = w.T @ X + b

w.T @ X는 여러 Example의 결과를 갖지만 b는 Scalar 하나다. NumPy는 b를 필요한 Shape로 자동 확장해서 계산한다.

Broadcasting은 편하지만 조심해야 한다.
Shape가 틀렸는데도 코드가 실행되는 경우가 있다. 그래서 Neural Network를 직접 구현할 때 assert로 Shape를 검증하는 습관이 유용하다.

assert(W.shape == (n_y, n_x))
assert(b.shape == (n_y, 1))

Week 2 전체를 코드로 압축하면

import numpy as np

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

def train(X, Y, lr=0.01, steps=1000):
    n_x, m = X.shape

    w = np.zeros((n_x, 1))
    b = 0.0

    for _ in range(steps):

        # Forward
        Z = w.T @ X + b
        A = sigmoid(Z)

        # Cost
        eps = 1e-12
        cost = -np.mean(
            Y * np.log(A + eps)
            + (1-Y) * np.log(1-A + eps)
        )

        # Backward
        dZ = A - Y
        dw = (X @ dZ.T) / m
        db = np.sum(dZ) / m

        # Update
        w -= lr * dw
        b -= lr * db

    return w, b

Week 2를 이해했다면 Neural Network Training의 핵심 Mechanism은 이미 배운 것이다. Week 3과 Week 4는 이것을 여러 Neuron과 여러 Layer로 확장한다.

WEEK 3

Neuron 하나로 부족하다: Hidden Layer

Logistic Regression 하나는 기본적으로 Linear Decision Boundary를 만든다. 현실의 패턴이 직선 하나로 나뉘지 않는다면 더 복잡한 함수를 표현해야 한다.

```

A⁽⁰⁾ = X

Z⁽¹⁾ = W⁽¹⁾A⁽⁰⁾ + b⁽¹⁾
A⁽¹⁾ = g⁽¹⁾(Z⁽¹⁾)

Z⁽²⁾ = W⁽²⁾A⁽¹⁾ + b⁽²⁾
A⁽²⁾ = g⁽²⁾(Z⁽²⁾)

A⁽²⁾ = Ŷ

왜 Non-linear Activation이 필요할까?

Z1 = W1X + b1

Z2 = W2Z1 + b2

   = W2(W1X+b1) + b2

   = (W2W1)X + (W2b1+b2)

새로운 W', b'로 묶으면 다시:

Z2 = W'X + b'

Linear Layer만 여러 개 쌓으면 전체는 여전히 Linear Function이다.
그래서 Layer 사이에 Non-linear Activation이 필요하다.

Activation Function

함수	수식	특징
Sigmoid	1/(1+e⁻ᶻ)	Binary Output
tanh	tanh(z)	-1~1, Zero-centered
ReLU	max(0,z)	단순하고 양수 영역 Gradient가 1
Leaky ReLU	max(αz,z)	음수 영역에도 작은 Gradient

sigmoid:
g'(z) = a(1-a)

tanh:
g'(z) = 1-a²

ReLU:
g'(z) = 1  if z > 0
        0  if z < 0

Shallow Network Backpropagation

# Forward

Z1 = W1 @ X + b1
A1 = tanh(Z1)

Z2 = W2 @ A1 + b2
A2 = sigmoid(Z2)


# Backward

dZ2 = A2 - Y

dW2 = (1/m) dZ2 @ A1.T
db2 = (1/m) Σ dZ2

dZ1 = (W2.T @ dZ2) * (1-A1²)

dW1 = (1/m) dZ1 @ X.T
db1 = (1/m) Σ dZ1

Backprop을 외우지 말고 이렇게 읽자.

Output이 얼마나 틀렸나?
↓
Output Weight는 얼마나 책임이 있나?
↓
그 책임을 Hidden Layer에 얼마나 넘길까?
↓
Activation Derivative를 통과하면 얼마나 줄어드나?
↓
Hidden Weight는 얼마나 책임이 있나?

Shape로 Backprop을 검산하자

nₓ = 2
n_h = 4
n_y = 1
m   = 100

Tensor	Shape	뜻
X	(2,100)	2 Features × 100 Examples
W1	(4,2)	4 Hidden Neurons × 2 Inputs
A1	(4,100)	4 Neurons × 100 Examples
W2	(1,4)	Output 1개가 Hidden 4개를 받음
A2	(1,100)	100개 예측

왜 Weight를 모두 0으로 시작하면 안 될까?

Hidden Layer의 모든 Neuron이 같은 Weight로 시작하면 같은 출력과 같은 Gradient를 받는다. 결국 여러 Neuron이 있어도 하나와 다르지 않다.

Symmetry Problem
모든 학생이 똑같은 답만 쓰는 교실을 생각하면 된다. 학생 수는 많지만 새로운 관점은 하나도 생기지 않는다.

W1 = np.random.randn(n_h, n_x) * 0.01
b1 = np.zeros((n_h, 1))

WEEK 4

한 층 더, 한 층 더: Deep Neural Network

Week 4에서는 새로운 마법이 등장하지 않는다. Week 3에서 만든 LINEAR → ACTIVATION Block을 반복한다.

A[0] = X

for l = 1 ... L:

    Z[l] = W[l] A[l-1] + b[l]

    A[l] = g[l](Z[l])

A[L] = Ŷ

Matrix Dimension을 구조로 이해하자

n[0] = 5
n[1] = 4
n[2] = 3
n[3] = 1

5 Inputs
   ↓
4 Neurons
   ↓
3 Neurons
   ↓
1 Output

W[1] : (4,5)
W[2] : (3,4)
W[3] : (1,3)

W[l] : (n[l], n[l-1])

b[l] : (n[l], 1)

A[l] : (n[l], m)

(n[l], n[l-1]) × (n[l-1], m)

= (n[l], m)

왜 Cache가 필요한가?

Backpropagation에서는 Forward 때 계산했던 값이 다시 필요하다. 예를 들어 dW[l]을 구하려면 A[l-1]이 필요하고, Activation Derivative에는 Z[l]이 필요하다.

Forward:
A_prev, W, b, Z
      ↓
    cache


Backward:
cache + upstream gradient
      ↓
dA_prev, dW, db

PyTorch 같은 Framework에서는 Autograd가 이 계산 Graph를 관리한다. 하지만 Framework가 대신 계산해주는 것과 Backpropagation의 원리를 모르는 것은 전혀 다른 이야기다.

Deep Network Backpropagation

dZ[l]
= dA[l] * g'[l](Z[l])


dW[l]
= (1/m) dZ[l] A[l-1]ᵀ


db[l]
= (1/m) Σ dZ[l]


dA[l-1]
= W[l]ᵀ dZ[l]

이 계산을 l=L, L-1, ..., 1 순서로 반복한다. Output에서 시작한 Gradient가 Network 앞쪽으로 흐르는 것이다.

왜 Deep Representation인가?

```

Parameter vs Hyperparameter

Parameters

Training 과정에서 모델이 배운다.

W[1], b[1]
W[2], b[2] ...

```

Hyperparameters

학습 방식을 사람이 정한다.

learning rate
layer count
hidden units
iterations

```

결국 Deep Learning Training은 이 Loop다

```

숫자 하나로 Training을 끝까지 따라가보자

x = 2
y = 1

w = 0.5
b = 0

learning rate α = 0.1

① Forward

z = wx+b
  = 0.5×2
  = 1

a = sigmoid(1)
  ≈ 0.731

② Loss

L = -log(0.731)
  ≈ 0.313

③ Backward

dz = a-y
   = 0.731-1
   = -0.269

dw = x × dz
   = 2 × (-0.269)
   = -0.538

db = -0.269

④ Update

w_new
= 0.5 - 0.1×(-0.538)
= 0.5538

b_new
= 0 - 0.1×(-0.269)
= 0.0269

다시 Forward하면:

z_new
= 0.5538×2 + 0.0269
= 1.1345

a_new
= sigmoid(1.1345)
≈ 0.757

0.731 → 0.757

정답 1에 조금 더 가까워졌다.

THIS IS TRAINING

이 작은 숫자 계산을 수많은 데이터와 수많은 Parameter에 대해 반복한 것이 거대한 Deep Learning Training의 기본 구조다.

이게 Transformer와 무슨 상관일까?

Course 1의 작은 Fully Connected Network와 현대 Transformer 사이에는 큰 Architecture 차이가 있다. 하지만 계산의 뼈대는 익숙하다.

Course 1	Transformer / LLM
Matrix Multiplication	Q/K/V Projection · MLP · Output Projection
Activation	GELU · SiLU · SwiGLU 계열
Forward	Token → Hidden State → Logits
Cross Entropy	Next-token Prediction Loss
Backprop	Pretraining · Fine-tuning
Vectorization	GPU Tensor Operation · Batch Processing

Architecture는 달라졌지만 그 아래에서는 여전히 Tensor가 곱해지고, Loss가 계산되고, Gradient가 역방향으로 흐른다.

금융 AI Engineer의 문제로 다시 연결해보자

X =
[
  income,
  debt_ratio,
  delinquency_count,
  credit_utilization,
  account_age
]

↓ Neural Network

ŷ = P(default = 1)

내부 계산은 우리가 지금 배운 것과 같다.

1. 고객 Feature를 X에 넣는다.

2. Forward
   Z1 = W1X+b1
   A1 = ReLU(Z1)
   Z2 = W2A1+b2
   A2 = sigmoid(Z2)

3. 실제 Default 여부 Y와 비교한다.

4. Cross Entropy Loss를 계산한다.

5. Backpropagation으로 Gradient를 계산한다.

6. Parameter를 Update한다.

하지만 Production에서는 여기서 끝나지 않는다. Class Imbalance · Data Leakage · Calibration · Threshold · Drift · Explainability · Model Version · Feature Lineage · Monitoring · Audit

이런 Production 문제를 이해하려면 먼저 “모델이 어떤 Loss를 줄이기 위해 어떤 Parameter를 어떻게 바꾸고 있는가?”를 이해해야 한다.

Course 1 수식 치트시트

# Logistic Regression Forward
z = wᵀx + b
a = sigmoid(z)

# Binary Cross Entropy
L = -[y log(a) + (1-y)log(1-a)]
J = (1/m) ΣL

# Logistic Regression Backward
dz = a-y
dw = x·dz
db = dz

# Vectorized
Z = wᵀX + b
A = sigmoid(Z)
dZ = A-Y
dw = (1/m)X dZᵀ
db = (1/m)ΣdZ

# Deep Layer Forward
Z[l] = W[l]A[l-1] + b[l]
A[l] = g[l](Z[l])

# Deep Layer Backward
dZ[l] = dA[l] * g'[l](Z[l])
dW[l] = (1/m)dZ[l]A[l-1]ᵀ
db[l] = (1/m)ΣdZ[l]
dA[l-1] = W[l]ᵀdZ[l]

# Update
W[l] ← W[l] - αdW[l]
b[l] ← b[l] - αdb[l]

처음 배울 때 가장 많이 헷갈리는 것

Loss와 Cost는 같은가?

Course 1의 기본 Notation에서는 Loss는 한 Example, Cost는 전체 Training Set의 목적함수라고 구분하면 편하다.

Backpropagation이 Gradient Descent인가?

아니다. Backpropagation은 Gradient를 계산하고, Gradient Descent는 그 Gradient를 이용해 Parameter를 수정한다.

Activation을 왜 넣는가?

여러 Linear Transformation만 쌓으면 결국 하나의 Linear Transformation으로 합쳐지기 때문이다.

왜 Hidden Layer의 W는 0 초기화가 안 되는가?

모든 Neuron이 같은 계산과 같은 Gradient를 받아 Symmetry가 깨지지 않기 때문이다.

Vectorization은 단순한 코드 최적화인가?

성능 최적화이면서 현대 Deep Learning 계산의 기본 표현 방식이다. GPU는 큰 Matrix와 Tensor를 병렬 처리하는 데 강하다.

10문제로 기초 확인

1. z=wᵀx+b에서 Weight와 Bias는 각각 어떤 역할을 하는가?
2. Sigmoid에서 z=0이면 왜 출력이 0.5인가?
3. Binary Cross Entropy가 자신 있게 틀린 예측을 크게 벌주는 이유는?
4. dZ=A-Y가 나오는 과정을 Chain Rule로 설명할 수 있는가?
5. Backpropagation과 Gradient Descent는 어떻게 다른가?
6. X.shape=(nₓ,m)에서 각 축은 무엇인가?
7. W[l].shape=(n[l],n[l-1])인 이유는?
8. Linear Layer만 여러 개 쌓으면 왜 여전히 Linear Function인가?
9. Hidden Layer Weight를 모두 0으로 초기화하면 무슨 일이 생기는가?
10. Deep Representation은 Image에서 어떤 계층 구조로 나타날 수 있는가?

마지막으로 머릿속에 하나의 그림만 남기자

THE MENTAL MODEL

```

Neuron은 입력을 가중합한다.
Activation은 Non-linearity를 만든다.
Forward Propagation은 예측을 만든다.
Loss는 얼마나 틀렸는지 측정한다.
Backpropagation은 틀린 책임을 뒤로 전달한다.
Gradient Descent는 책임만큼 Parameter를 고친다.
Vectorization은 이 계산을 대규모로 실행한다.

```

처음 Deep Learning을 보면 수백만, 수십억 개 Parameter가 등장해 거대한 수학 괴물처럼 보인다. 하지만 가까이 다가가면 놀랍도록 반복적이다.

Z = WA + b
A = g(Z)

앞으로 계산한다.
틀린 정도를 잰다.
미분해서 뒤로 보낸다.
W를 조금 바꾼다.

Andrew Ng의 첫 Course가 좋은 이유는 이 구조를 Framework 뒤에 숨기지 않고 직접 만들어보게 한다는 데 있다. 이 기반이 잡히면 CNN, Transformer, Fine-tuning을 볼 때도 완전히 다른 세계처럼 느껴지지 않는다.

ONE LINE REVIEW

딥러닝의 기초는 Neural Network 공식을 외우는 것이 아니라,
Forward → Loss → Backward → Update라는
하나의 학습 시스템을 이해하는 것이다.

---

References

• DeepLearning.AI — Deep Learning Specialization
• Coursera — Neural Networks and Deep Learning, Course 1
• DeepLearning.AI Community — DLS Course 1 Lecture Notes
• Course 1 Programming Assignments — Python Basics with NumPy, Logistic Regression, Planar Data Classification, Deep Neural Network

※ Course 1의 Week 1~4 학습 흐름을 독립적으로 이해할 수 있도록 재구성한 학습용 Deep Dive다. 강의 Transcript를 그대로 옮긴 것이 아니라 핵심 수식의 직관, 숫자 예제, Matrix Shape, 현대 LLM Engineering 연결을 추가했다.