📚 부산디지털대학교 '파이썬 기반의 AI프로그래밍' 5주차 강의노트와 직접 실습한 코랩 노트를 바탕으로 정리한 학습 노트입니다. (출처는 글 하단 참고)

01 실습 준비 — Matplotlib으로 데이터 보기

1강 · 숫자를 그래프로 바꿔 주는 시각화 라이브러리

4주차에서 개념으로 배운 경사 하강법을 이번 주에는 코드로 직접 돌려 봅니다. 먼저 결과를 눈으로 확인할 수 있도록 Matplotlib(맷플롯립)을 불러옵니다. Matplotlib은 파이썬에서 데이터 시각화에 가장 널리 쓰이는 라이브러리로, 다양한 유형의 그래프와 플롯을 그릴 수 있습니다.

데이터를 산점도로 그려 보기

import numpy as np
import matplotlib.pyplot as plt # 시각화 라이브러리

x = np.array([2, 4, 6, 8]) # 공부 시간
y = np.array([81, 93, 91, 97]) # 성적

plt.scatter(x, y) # 점 찍기
plt.show() # 화면에 표시

▶ 실행 결과 (그래프 출력)

(출력 영역에 4개의 점이 찍힌 산점도가 나타남 — 아래 그림 1)

02 경사 하강법 실습 코드 한 줄씩 읽기

4주차 개념이 그대로 코드가 된다

경사 하강법으로 기울기 a와 절편 b 찾기

#초기 변수 설정
a = 0 #기울기
b = 0 #절편
lr = 0.03 #학습률
epochs = 2001 #학습 반복 횟수
n = len(x) #데이터 포인트의 수

for i in range(epochs):
    y_pred = a * x + b #예측 값 계산
    error = y - y_pred #오차 계산
    a_diff = (2/n) * sum(-x * (error)) #기울기의 변화량(a에 대한 편미분 수행)
    b_diff = (2/n) * sum(-(error)) #오차의 합을 통한 절편의 변화량(b에 대한 편미분 수행)
    a = a - lr * a_diff #학습률 이용하여 기울기 업데이트
    b = b - lr * b_diff #학습률 이용하여 절편 업데이트
    if i % 100 == 0: #100 에포크마다 출력
        print("epoch=%.f, 기울기=%.04f, 절편=%.04f" % (i, a, b))

▶ 실행 결과 (lr = 0.03, epochs = 2001 (중간 일부 생략))

epoch=0, 기울기=27.8400, 절편=5.4300
epoch=100, 기울기=7.0739, 절편=50.5117
epoch=200, 기울기=4.0960, 절편=68.2822
epoch=300, 기울기=2.9757, 절편=74.9678
epoch=400, 기울기=2.5542, 절편=77.4830
epoch=500, 기울기=2.3956, 절편=78.4293
⋮
epoch=1000, 기울기=2.3007, 절편=78.9957
⋮
epoch=1500, 기울기=2.3000, 절편=79.0000
⋮
epoch=2000, 기울기=2.3000, 절편=79.0000

처음에는 기울기가 27.84로 크게 튀지만, 반복할수록 기울기 2.3, 절편 79로 수렴합니다. 3주차 최소 제곱법, 4주차 미리 보기에서 구한 값과 똑같습니다.

📖 에포크(epoch)란?
가지고 있는 데이터 전체를 한 번 다 사용해 학습하는 것을 1 에포크라고 합니다. epochs = 2001이면 데이터 4개 전체로 a와 b를 2,001번 고친다는 뜻입니다. range(2001)은 0부터 2000까지이므로, i % 100 == 0 조건으로 0, 100, …, 2000번째에 모두 21번 출력됩니다.

❌ 강의노트 코드를 복사할 때 주의 — 긴 대시(–)
강의노트 PDF의 error = y – y_pred에 들어 있는 기호는 키보드의 빼기(-)가 아니라 긴 대시(–, U+2013)입니다. 그대로 복사해 실행하면 SyntaxError: invalid character '–' (U+2013) 오류가 납니다. 코랩에 붙여 넣은 뒤에는 빼기 기호를 키보드로 다시 입력하세요.

❌ 시험 함정 — 경사 하강법은 "편미분"
경사 하강법에서 a와 b를 구할 때는 식 전체를 미분하는 것이 아니라, 필요한 값인 a와 b를 중심으로 각각 미분합니다. 즉 편미분을 수행해 예측선을 만듭니다. 코드의 a_diff와 b_diff가 바로 그 두 편미분 값입니다.

결과를 그래프로 확인하기

최종 예측선 그리기

#최종 예측과 시각화
y_pred = a * x + b
plt.scatter(x, y) # 실제 점수(점) - 산점
plt.plot(x, y_pred, 'r') # 예측선(빨간 직선)
plt.show()

▶ 실행 결과 (그래프 출력)

(점 4개를 가로지르는 빨간 예측선 y = 2.3x + 79가 나타남 — 아래 그림 2)

✓ plot의 'r'은?
plt.plot()의 세 번째 인자는 선의 색과 모양을 정하는 형식 문자열입니다. 'r'은 red(빨간색) 실선, 'b'는 파란색, 'g--'는 초록 점선입니다.

03 다중 선형 회귀란?

2강 · 성적은 공부 시간만으로 정해지지 않는다

지금까지는 공부한 시간 하나로 성적을 예측했습니다. 하지만 실제 성적에는 공부 시간 말고도 다른 요소가 영향을 줍니다. 그래서 등장하는 것이 다중 선형 회귀입니다.

📖 다중 선형 회귀 (Multiple Linear Regression)
하나의 종속 변수와 두 개 이상의 독립 변수 간의 관계를 모델링하는 통계 기법
· 종속 변수(Dependent Variable) : 예측하고자 하는 변수, 보통 Y로 표기
· 독립 변수(Independent Variables) : 종속 변수에 영향을 미치는 변수

공부한 시간(x₁)에 과외 수업 시간(x₂)이라는 독립 변수를 하나 더 추가한 새 데이터입니다.

y = a₁x₁ + a₂x₂ + b
a₁ : 공부 시간의 기울기  |  a₂ : 과외 시간의 기울기  |  b : 절편

❌ 시험 함정 — 다중 선형 회귀는 "변수 개수를 늘리는" 방식
일반 선형 회귀가 하나의 변수를 기준으로 예측한다면, 다중 선형 회귀는 정보를 가진 변수의 개수를 늘려 예측 정확도를 높이는 방식입니다. 그래서 2차원의 예측 직선이 아니라 다차원의 예측 평면을 조절하게 됩니다.

04 다중 선형 회귀 실습

기울기가 두 개, 편미분도 세 번

3D 산점도로 데이터 분포 보기

import numpy as np
import matplotlib.pyplot as plt

#공부 시간 x1과 과외 시간 x2, 성적 y의 넘파이 배열
x1 = np.array([2, 4, 6, 8])
x2 = np.array([0, 4, 2, 3])
y = np.array([81, 93, 91, 97])

#시각적 데이터 분포(3D) 확인
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d') # 3D 좌표축 만들기
ax.scatter3D(x1, x2, y) # ax.scatter(x1, x2, y)로 써도 똑같이 동작
plt.show()

▶ 실행 결과 (그래프 출력)

(x1·x2·y 세 축으로 된 3D 공간에 점 4개가 나타남 — 아래 그림 3)

✓ scatter3D와 scatter
projection='3d'로 만든 3D 좌표축(Axes3D)에서는 2D 그래프에서 쓰던 ax.scatter(x1, x2, y)를 그대로 써도 3D 산점도가 그려집니다. 강의노트의 scatter3D도 그대로 유효하므로 둘 중 편한 쪽을 쓰면 됩니다.

경사 하강법으로 a1, a2, b 찾기

#기울기와 절편 값 초기화
a1 = 0
a2 = 0
b = 0
lr = 0.01 #학습률
epochs = 2001
n = len(x1)

for i in range(epochs):
    y_pred = a1 * x1 + a2 * x2 + b #예측 값 계산
    error = y - y_pred #실제 값과 비교한 오차
    a1_diff = (2/n) * sum(-x1 * (error)) #오차함수를 a1으로 편미분
    a2_diff = (2/n) * sum(-x2 * (error)) #오차함수를 a2로 편미분
    b_diff = (2/n) * sum(-(error)) #오차함수를 b로 편미분
    a1 = a1 - lr * a1_diff #학습률을 이용하여 기존 값 업데이트
    a2 = a2 - lr * a2_diff
    b = b - lr * b_diff
    if i % 100 == 0:
        print("epoch=%.f, 기울기1=%.04f, 기울기2=%.04f, 절편=%.04f" % (i, a1, a2, b))

print("실제 점수:", y)
print("예측 점수:", y_pred)

▶ 실행 결과 (lr = 0.01, epochs = 2001 (중간 일부 생략))

epoch=0, 기울기1=9.2800, 기울기2=4.2250, 절편=1.8100
epoch=100, 기울기1=9.5110, 기울기2=5.0270, 절편=22.9205
epoch=500, 기울기1=3.7447, 기울기2=3.0608, 절편=62.4448
⋮
epoch=1000, 기울기1=1.9583, 기울기2=2.4440, 절편=74.7103
⋮
epoch=1500, 기울기1=1.5936, 기울기2=2.3180, 절편=77.2146
⋮
epoch=2000, 기울기1=1.5191, 기울기2=2.2923, 절편=77.7260
실제 점수: [81 93 91 97]
예측 점수: [80.76387645 92.97153922 91.42520875 96.7558749 ]

예측 점수가 실제 점수 81, 93, 91, 97에 거의 붙었습니다. 독립 변수가 하나 늘었을 뿐인데 예측이 훨씬 정확해졌습니다.

📖 심화 — 2001번으로는 아직 끝까지 내려가지 않았다
같은 데이터를 최소 제곱법으로 정확히 풀면 a₁ = 1.5, a₂ ≈ 2.2857, b ≈ 77.8571입니다. 실습 결과(1.5191, 2.2923, 77.7260)는 그 근처까지 왔지만 아직 계속 움직이는 중입니다. 변수가 늘어나고 학습률이 0.01로 작아져 수렴이 느려졌기 때문입니다. epochs를 더 늘리면 이 값에 더 가까워집니다(7장 텐서플로 실습에서 5,000번 학습하면 1.5002, 2.2858, 77.856). 4주차에서 배운 "학습률이 작으면 수렴이 느리다"를 실제로 확인할 수 있는 부분입니다.

✓ 예측 점수 출력에 대해 한 가지 더
마지막 print("예측 점수:", y_pred)의 y_pred는 반복문 마지막 회차의 업데이트 직전 a₁, a₂, b로 계산한 값입니다. 업데이트가 아주 작게 일어나는 단계라 결과 차이는 소수점 셋째 자리 수준이지만, 최종 값으로 예측하려면 반복문이 끝난 뒤 y_pred = a1 * x1 + a2 * x2 + b를 한 번 더 계산하면 됩니다.

05 텐서플로(TensorFlow)란?

3강 · 구글 브레인팀이 만든 딥러닝 오픈 소스

✓ "자동 미분"이 왜 중요할까?
1·2강에서는 a_diff, b_diff처럼 편미분 식을 사람이 직접 코드로 썼습니다. 변수가 수백만 개인 딥러닝에서는 이걸 손으로 쓸 수 없습니다. 텐서플로는 모델과 손실 함수만 정하면 편미분을 알아서 계산해 줍니다. 7장 코드에 미분 식이 한 줄도 없는 이유입니다.

📖 보충 — 지원 언어와 데이터 플로 그래프의 현재
· 강의노트의 "R[2]"에서 [2]는 원문 자료의 각주 번호가 남은 것으로 보입니다.
· 텐서플로 공식 API 문서 기준으로 API 안정성(하위 호환)이 보장되는 것은 Python뿐입니다. JavaScript·C++·Java는 공식 지원하지만 안정성 보장 대상이 아니고, R은 커뮤니티가 지원하며, Go는 보관(archived) 상태입니다.
· SWIG를 통한 언어 연결과 "데이터 플로 그래프를 먼저 만들고 실행"하는 방식은 주로 텐서플로 1.x 시절의 특징입니다. 텐서플로 2.x부터는 코드를 바로 실행하는 즉시 실행(eager execution)이 기본이고, 그래프는 필요할 때 tf.function으로 만듭니다.
(근거: TensorFlow 공식 문서 「API Documentation」)

06 머신러닝 용어 vs 딥러닝 용어

같은 개념, 다른 이름

텐서플로 같은 딥러닝 도구를 쓰기 시작하면 지금까지 쓰던 말이 다른 이름으로 바뀝니다. 개념은 그대로이니 짝을 지어 기억하세요.

H(x) = wx + b
2주차 뉴런 y = f(wx + b)에서 활성화 함수 f를 뺀 모양과 같음

왜 용어가 달라졌을까?

❌ 시험 함정 — 기울기 a는 "가설 함수"가 아니라 "가중치"
기울기 a는 변수 x에 어느 정도의 가중치를 곱할지 결정하므로 가중치(weight)라고 부릅니다. 가설 함수는 가정하는 식 전체를 가리키는 말로 H(x)로 표기합니다. 나머지 짝(오차 식 = 손실 함수, 절편 b = 편향, 경사 하강법 = 옵티마이저)도 함께 외워 두세요. 강의노트는 가중치를 ω(오메가)로 표시하지만, 교재와 코드에서는 보통 알파벳 w를 씁니다.

07 텐서플로로 선형 회귀 · 다중 선형 회귀

내 코랩 실습 + 다중 선형 회귀 보충 (편미분 식 없이 학습)

3강 실습 코드를 코랩에서 셀 단위로 나눠 직접 실행했습니다. ①~④의 코드와 실행 결과는 제 코랩 노트(5주 3강.ipynb)에 있는 그대로입니다. 2주차에서 본 Sequential과 Dense를 그대로 씁니다.

① 준비 · 모델 만들기

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

x = np.array([2,4,6,8,])
y = np.array([81,93,91,97])

model = Sequential()
model.add(Dense(1,input_dim=1, activation = 'linear'))

▶ 실행 결과 (코랩 실행 — 경고 메시지)

/usr/local/lib/python3.13/dist-packages/keras/src/layers/core/dense.py:106: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)

⚠️ UserWarning는 오류가 아니다
빨간 글씨로 나와서 놀랄 수 있지만 경고(Warning)일 뿐이고 모델은 정상으로 만들어집니다. Dense(1, input_dim=1)처럼 첫 층에 입력 크기를 함께 적는 방식은 예전 케라스 문법이라, 최신 Keras 3가 "첫 층으로 Input(shape) 객체를 쓰라"고 권하는 것입니다(2주차 9장 팁과 같은 내용). 경고 없이 쓰려면 Sequential([Input(shape=(1,)), Dense(1, activation='linear')])처럼 Input을 맨 앞에 두면 됩니다. x 배열의 [2,4,6,8,]처럼 마지막에 붙은 쉼표는 파이썬에서 허용되는 문법이라 결과에 영향이 없습니다.

② 컴파일 · 학습

model.compile(optimizer='sgd', loss = 'mse') # 옵티마이저: 경사 하강법(SGD), 손실 함수: 평균 제곱 오차
model.fit(x, y, epochs=2000) # 2000 에포크 학습

▶ 실행 결과 (코랩 실행 (2000줄 중 일부))

Epoch 1/2000
1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 1s/step - loss: 9332.1045
Epoch 2/2000
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step - loss: 2198.9106
Epoch 3/2000
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 47ms/step - loss: 1145.9053
⋮
Epoch 500/2000
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 57ms/step - loss: 46.2271
⋮
Epoch 1000/2000
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 57ms/step - loss: 9.7735
⋮
Epoch 2000/2000
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 141ms/step - loss: 8.3022

loss(손실)는 매 에포크의 평균 제곱 오차입니다. 처음 9,332에서 시작해 마지막에는 8.3022까지 내려갔습니다. 3·4주차에서 구한 가장 좋은 직선 y = 2.3x + 79의 평균 제곱 오차가 8.30이므로, 텐서플로도 거의 같은 직선을 찾아냈다는 뜻입니다.

✓ 코드 읽기 포인트
· optimizer='sgd' : 확률적 경사 하강법(Stochastic Gradient Descent). 문자열로만 적으면 기본 학습률 0.01이 쓰입니다. 학습률을 직접 정하려면 tf.keras.optimizers.SGD(learning_rate=0.03)처럼 씁니다.
· loss='mse' : 손실 함수로 평균 제곱 오차 사용
· fit()의 출력 : verbose를 따로 정하지 않으면 에포크마다 진행 막대와 loss가 한 줄씩 찍힙니다. 출력을 숨기려면 verbose=0을 넣습니다.

③ 예측선 그래프 그리기

plt.scatter(x, y)
plt.plot(x, model.predict(x), 'r') # 학습된 모델의 예측값을 빨간 선으로
plt.show()

▶ 실행 결과 (코랩 실행)

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 106ms/step
(점 4개와 빨간 예측선이 나타남 — 아래 그림 4)

④ 7시간 공부했을 때 점수 예측

hour = 7
prediction = model.predict(np.array([[hour]], dtype=float))
print("%.f시간 공부할 경우 예상점수는 %.02f점이다." % (hour, prediction))

▶ 실행 결과 (코랩 실행)

1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 98ms/step
7시간 공부할 경우 예상점수는 95.12점이다.
/tmp/ipykernel_3173/1329501818.py:3: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)
  print("%.f시간 공부할 경우 예상점수는 %.02f점이다." % (hour, prediction))

예측 점수 95.12점은 y = 2.3x + 79에 x = 7을 넣은 값(95.1점)과 거의 같습니다.

⚠️ 실습하며 발견한 점 — DeprecationWarning
model.predict()는 숫자 하나가 아니라 모양이 (1, 1)인 2차원 배열 [[95.12…]]를 돌려줍니다. 이 배열을 그대로 "%.02f"에 넣으면 지금은 NumPy가 숫자로 바꿔 주지만, "앞으로는 오류가 될 것"이라는 경고가 나옵니다. 배열에서 값 하나를 꺼내 prediction[0][0] 또는 prediction.item()으로 넘기면 경고 없이 같은 결과가 나옵니다.
예) print("%.f시간 공부할 경우 예상점수는 %.02f점이다." % (hour, prediction[0][0]))

다중 선형 회귀도 텐서플로로

다중 선형 회귀는 텐서플로로 실습하지 않아서, 같은 방식으로 코드를 직접 작성해 실행했습니다. 경고가 나오지 않도록 Input을 맨 앞에 두었고, 실행할 때마다 같은 결과가 나오도록 시작값을 고정했습니다.

⑤ 텐서플로로 다중 선형 회귀 (보충 코드)

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, Dense

tf.keras.utils.set_random_seed(42)

x = np.array([[2, 0], [4, 4], [6, 2], [8, 3]]) # [공부 시간, 과외 시간] 4명분 → 모양 (4, 2)인 2차원 행렬
y = np.array([81, 93, 91, 97])

model = Sequential([Input(shape=(2,)), Dense(1, activation='linear')]) # H(x) = w1x1 + w2x2 + b
model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.01), loss='mse')
model.fit(x, y, epochs=5000, verbose=0)

w, b = model.get_weights()
print("가중치 w1 =", round(float(w[0][0]), 4), " w2 =", round(float(w[1][0]), 4))
print("편향 b =", round(float(b[0]), 4))
print("예측 점수:", model.predict(x, verbose=0).flatten().round(2))

▶ 실행 결과 (TensorFlow 2.21 / CPU)

가중치 w1 = 1.5002  w2 = 2.2858
편향 b = 77.856
예측 점수: [80.86 93.   91.43 96.71]

📖 x1, x2를 따로 넘기던 것을 하나의 행렬로
4장에서 직접 구현할 때는 x1(공부 시간)과 x2(과외 시간)를 1차원 배열 두 개로 따로 다뤘습니다. 텐서플로 모델에 넣을 때는 이를 2차원 행렬 하나로 묶습니다. 한 행이 학생 한 명, 한 열이 특성(독립 변수) 하나라서 모양이 (4, 2)가 되고, 그래서 Input(shape=(2,))로 특성 2개를 받습니다. 이미 x1, x2가 있다면 x = np.column_stack((x1, x2))로 같은 행렬을 만들 수 있습니다.

⚠️ 실행할 때마다 끝자리가 조금씩 다를 수 있다
텐서플로는 가중치를 무작위 값에서 시작합니다. 그래서 같은 코드를 다시 실행하면 loss나 예측 점수의 소수점 끝자리가 조금씩 달라질 수 있습니다(내 실습 ①~④는 시작값을 고정하지 않은 결과입니다). 매번 같은 결과를 원하면 ⑤처럼 tf.keras.utils.set_random_seed(42)로 고정하면 됩니다. ⑤의 결과는 TensorFlow 2.21(CPU)에서 실행한 값이며, 환경에 따라 끝자리는 조금 다를 수 있습니다. 어떤 경우든 단순 회귀는 2.3과 79, 다중 회귀는 1.5·2.29·77.86 근처로 모입니다.

✓ 직접 구현 vs 텐서플로
1·2강 코드는 a_diff, b_diff 같은 편미분 식을 사람이 직접 썼고, 텐서플로 코드에는 미분 식이 없습니다. compile()에서 손실 함수와 옵티마이저만 정해 주면 텐서플로가 자동 미분으로 기울기를 계산해 가중치와 편향을 고칩니다. 결과는 두 방법 모두 같은 답으로 모입니다.

08 핵심 정리

시험 직전에 이것만은 꼭

📌 핵심 정리

· 경사 하강법 실습 : a와 b를 중심으로 각각 미분 = 편미분 (식 전체 미분 X). a_diff = (2/n)Σ(−x·error), b_diff = (2/n)Σ(−error)
· 업데이트 : a = a − lr × a_diff, b = b − lr × b_diff를 epochs만큼 반복 → 기울기 2.3, 절편 79
· Matplotlib : 그래프로 시각적 확인. scatter(산점도), plot(직선), show(표시), title·xlabel·ylabel, legend, grid
· 다중 선형 회귀 : 하나의 종속 변수와 두 개 이상의 독립 변수 관계 모델링. y = a₁x₁ + a₂x₂ + b
· 다중 선형 회귀의 장점 : 현실 반영, 정확도 향상(MSE 8.3 → 약 0.07), 변수 간 상호작용 분석, 변수별 영향 평가. 직선이 아닌 3D 평면
· 텐서플로 : 구글 브레인팀 개발 오픈 소스. 데이터 플로 그래프, 테스트~서비스 단계 활용, 자동 미분
· 용어 짝 : 가정하는 식 = 가설 함수 H(x) / 기울기 a = 가중치(weight) / 절편 b = 편향(bias) / 오차 식 = 손실 함수 / 경사 하강법 = 옵티마이저
· 용어가 다른 이유 : 기술적 차이(모델 구조) · 복잡성 차이(데이터 처리 수준) · 학습 방식 차이 · 응용 분야 차이

태그 : 경사 하강법 파이썬 코드편미분 경사 하강법matplotlib scatter plot다중 선형 회귀란단순 선형회귀 다중 선형회귀 차이다중 선형 회귀 파이썬텐서플로란가중치 편향 손실함수 옵티마이저텐서플로 선형 회귀 예제케라스 Dense 선형 회귀

출처 : 이 글은 부산디지털대학교(BDU)의 '파이썬 기반의 AI프로그래밍' 과목 2026년도 강의노트를 참고하여 학습용으로 작성한 글입니다.

📚 부산디지털대학교 '파이썬 기반의 AI프로그래밍' 4주차 강의노트와 직접 실습한 코랩 노트를 바탕으로 정리한 학습 노트입니다. (출처는 글 하단 참고)

01 최소 제곱법의 한계와 "먼저 긋고 수정하기"

1강 · 공식 한 번이 아니라, 조금씩 고쳐 가는 방식으로

3주차에서는 최소 제곱법 공식 한 번으로 기울기 a = 2.3과 y절편 b = 79를 정확히 구했습니다. 그런데 이 방법으로 앞으로 만나게 될 모든 상황을 해결하기는 어렵습니다. 특히 입력(x)이 여러 개인 경우를 처리하기에 무리가 있습니다.

📖 이 방식에 꼭 필요한 것
선을 긋고 고쳐 나가려면 "나중에 그린 선이 먼저 그린 선보다 더 좋은지 나쁜지"를 판단할 수 있어야 합니다. 그러려면
· 각 선의 오차를 계산할 수 있어야 하고
· 오차가 작은 쪽으로 바꾸는 알고리즘이 필요합니다.
이때 주어진 선의 오차를 평가하는 방법이 바로 평균 제곱 오차입니다.

02 임의의 직선 긋고 오차 재기

가설: 기울기 3, y절편 76

3주차와 같은 데이터(공부 시간 2·4·6·8시간, 성적 81·93·91·97점)에 기울기 a = 3, y절편 b = 76이라는 임의의 직선을 그어 보겠습니다.

y = 3x + 76
가설로 세운 임의의 직선

이 직선이 얼마나 틀렸는지 알려면 각 점과 직선 사이의 거리를 재면 됩니다. 거리는 y의 실제 값과, x를 y = 3x + 76에 넣어 나온 예측 값의 차이입니다. 예를 들어 2시간 공부한 학생의 실제 점수는 81점, 식에 x = 2를 넣은 예측 점수는 82점이므로 그 차이가 오차입니다.

📖 오차와 직선의 관계
· 점과 직선 사이 거리(오차)들의 합이 작을수록 잘 그어진 직선, 클수록 잘못 그어진 직선
· 기울기가 잘못될수록 오차의 합이 커짐
· 기울기가 무한대로 커지면 오차도 무한대로 커지는 상관관계

❌ 시험 함정 — "잘 그어진 직선"의 기준
평균 제곱 오차 방식에서는 실제 값과 예측선의 차이를 오차로 봅니다. 이 오차가 작을수록 잘 그어진 예측선입니다. 반대로 기울기가 잘못될수록 오차는 커집니다.

📖 보충 — "차이의 합"이 아니라 "차이를 제곱한 값의 합(평균)"
강의노트 1강 평가 해설은 "차이 값들의 합이 작을수록 잘 그어진 직선"이라고 설명하지만, 바로 다음 2강에서 보듯 차이를 그냥 더하면 양수와 음수가 서로 지워져 실제 오차 크기를 알 수 없습니다(이 예에서 합은 겨우 2). 정확한 기준은 오차를 제곱해 더한 값, 또는 그 평균인 평균 제곱 오차가 작을수록 잘 그어진 직선이라는 것입니다. 시험에서는 강의노트 기준(O)으로 답하되, 그 "합"은 부호를 없앤 합이라고 이해해 두세요.

03 평균 제곱 오차(MSE) 계산하기

2강 · 더하기 → 제곱하기 → 평균 내기

오차를 그냥 더하면 2밖에 되지 않습니다. 실제로는 −5점이나 틀린 점도 있는데, 양수와 음수가 섞여 서로 지워졌기 때문입니다. 경우에 따라서는 합이 0이 될 수도 있습니다. 그래서 부호를 없애야 정확한 오차를 계산할 수 있고, 그 방법이 제곱입니다.

MSE = (1/n) Σ (y_i − ŷ_i)²
n : 데이터 개수  |  y_i : 실제 값  |  ŷ_i(와이 햇) : 예측 값

📖 평균 제곱 오차 (Mean Squared Error, MSE)
· 각 오차를 제곱해 모두 더한 오차 제곱합을
· 데이터 개수 n으로 나눈 값
· 이 예제 : 오차 제곱합 44, n = 4 → MSE = 44 ÷ 4 = 11

NumPy 배열을 쓰면 이 과정을 한 줄씩 그대로 확인할 수 있습니다.

오차 → 제곱 → 평균, 단계별로 확인하기

import numpy as np

x = np.array([2, 4, 6, 8])
y = np.array([81, 93, 91, 97])

y_pred = 3 * x + 76 # 임의의 직선으로 예측
error = y_pred - y # 오차 (예측 - 실제)
print("오차 :", error)
print("오차의 합 :", error.sum())
print("오차 제곱 :", error ** 2)
print("오차 제곱의 합 :", (error ** 2).sum())
print("평균 제곱 오차 :", (error ** 2).mean())

▶ 실행 결과 (a = 3, b = 76)

오차 : [ 1 -5  3  3]
오차의 합 : 2
오차 제곱 : [ 1 25  9  9]
오차 제곱의 합 : 44
평균 제곱 오차 : 11.0

⚠️ 오차의 부호는 어느 쪽으로 빼도 된다
강의노트는 오차를 예측 − 실제(1, −5, 3, 3)로 계산했고, 실습 코드의 mse() 함수는 실제 − 예측(y − y_pred)으로 계산합니다. 부호만 반대일 뿐, 제곱하면 똑같은 값이 되므로 MSE는 어느 쪽이든 11로 같습니다.

❌ 시험 함정 — 평균 제곱 오차 방식이 하는 일
선형 회귀의 평균 제곱 오차 방식은 임의의 직선을 그어 평균 제곱 오차를 구하고, 이 값을 가장 작게 만들어 주는 a값과 b값을 찾아가는 작업입니다. 예측선과 실제 값 사이의 오차를 줄여 최적의 예측선을 찾는다고 기억하세요.

04 내 코랩 실습 — 평균 제곱 오차 구하기

직접 실행한 코드와 결과 그대로

2강 실습 코드를 코랩에서 셀 단위로 나눠 실행했습니다. 아래 코드와 실행 결과는 제 코랩 노트(4주 2강.ipynb)에 있는 그대로입니다.

① 준비 · 예측 함수 · 예측 점수 출력

import numpy as np

#가상의 기울기 a와 절편 b를 지정
fake_a = 3
fake_b = 76

x = np.array([2, 4, 6, 8])
y = np.array([81, 93, 91, 97])

#y = ax + b 적용하기 위한 함수 정의
def predict(x):
    return fake_a * x + fake_b

predict_result = [] #예측 점수를 받기 위한 배열 선언

for i in range(len(x)):
    predict_result.append(predict(x[i])) #예측 점수를 선언한 배열에 추가(append)
    print("공부 시간 : %.f, 실제 점수: %.f, 예측점수: %.f" %(x[i], y[i], predict(x[i])))

▶ 실행 결과 (코랩 실행)

공부 시간 : 2, 실제 점수: 81, 예측점수: 82
공부 시간 : 4, 실제 점수: 93, 예측점수: 88
공부 시간 : 6, 실제 점수: 91, 예측점수: 94
공부 시간 : 8, 실제 점수: 97, 예측점수: 100

✓ 코드 읽기 포인트
· predict(x) : y = ax + b 공식을 함수로 만든 것. fake_a, fake_b는 "가짜(임의로 정한)" 기울기와 절편이라는 뜻
· append() : 리스트 맨 뒤에 값을 하나씩 추가
· "%.f" % 값 : 소수점 없이(반올림해서) 숫자를 끼워 넣는 문자열 포맷. %.1f라면 소수점 첫째 자리까지 출력

② 평균 제곱 오차 함수 정의와 출력

n = len(x)
def mse(y, y_pred):
    return (1/n) * sum((y-y_pred)**2)

print("평균 제곱 오차 : " + str(mse(y, predict_result)))

▶ 실행 결과 (코랩 실행)

평균 제곱 오차 : 11.0

③ 같은 값을 쉼표(,)로 출력해 보기

print("평균 제곱 오차 : ", mse(y, predict_result))

▶ 실행 결과 (코랩 실행)

평균 제곱 오차 :  11.0

손으로 계산한 값과 똑같이 MSE = 11.0이 나왔습니다.

✓ 실습하며 발견한 점 ① — 출력에 띄어쓰기가 하나 더 생긴 이유
②는 "…: " + str(값)처럼 문자열을 이어 붙였고, ③은 print("…: ", 값)처럼 쉼표로 나눠 넘겼습니다. print()는 쉼표로 나뉜 값 사이에 공백 한 칸을 자동으로 넣기 때문에, 문자열 끝의 공백과 합쳐져 ③에는 콜론 뒤 공백이 두 칸이 됩니다. 숫자를 + 로 이어 붙일 때는 str()로 문자열로 바꿔야 한다는 점도 함께 기억하세요.

⚠️ 실습하며 발견한 점 ② — 리스트와 배열의 빼기
predict_result는 리스트인데 y - y_pred가 잘 계산된 이유는 y가 NumPy 배열이기 때문입니다. 배열과 리스트를 빼면 NumPy가 리스트를 배열로 바꿔 원소끼리 계산해 줍니다. 만약 y도 일반 리스트였다면 TypeError: unsupported operand type(s) for -: 'list' and 'list' 오류가 납니다. 리스트끼리는 빼기를 할 수 없기 때문입니다.

05 기울기 a와 오차의 관계

3강 · 오차를 그래프로 그리면 포물선이 된다

기울기 a를 너무 크게 잡아도, 너무 작게 잡아도 오차가 커집니다. 기울기가 무한대로 커지거나 작아지면 직선은 y축과 나란해지고 오차도 무한대가 됩니다. 그래서 기울기 a와 오차 사이에는 이차 함수의 관계가 있습니다.

y절편을 b = 79로 고정하고 기울기 a만 바꿔 가며 MSE를 계산해 보겠습니다.

기울기 a에 따른 MSE 변화 (b = 79 고정)

def mse(a, b):
    return np.mean((y - (a * x + b)) ** 2)

for a in [1.0, 2.0, 2.3, 3.0, 4.0]:
    print(f"a = {a} → MSE = {mse(a, 79):.2f}")

▶ 실행 결과 (b = 79 고정)

a = 1.0  →  MSE = 59.00
a = 2.0  →  MSE = 11.00
a = 2.3  →  MSE = 8.30
a = 3.0  →  MSE = 23.00
a = 4.0  →  MSE = 95.00

a가 2.3에서 멀어질수록 MSE가 커지고, a = 2.3에서 가장 작습니다(8.30). 3주차 최소 제곱법으로 구한 기울기와 같은 값이고, 오차 제곱합 33.2를 4로 나눈 값이 바로 8.3입니다. 이 값들을 그래프로 그리면 아래로 볼록한 포물선이 됩니다.

06 경사 하강법 — 미분 값이 0인 곳을 찾아서

1주차 미분이 드디어 등장하는 순간

포물선 위의 a₁, a₂, m에서 각각 미분하면 그 자리의 순간 기울기(접선)를 얻습니다. 포물선의 꼭짓점 m에서는 접선이 x축과 평행하므로 기울기가 0입니다. 즉, 최적의 a를 찾는 일은 "미분 값이 0인 지점"을 찾는 일입니다.

📖 경사 하강법 (gradient descent)
· 미분 기울기를 이용해, 반복적으로 기울기 a를 변화시켜서 m값(미분 값이 0인 지점)을 찾아내는 방법
· 강의노트 영문 표기 : gradient decent(→ 바른 철자는 gradient descent, descent = 내려감)

경사 하강법의 순서

학습률 (learning rate) — 얼마나 멀리 이동할까

기울기의 부호를 보고 이동할 때 적절한 거리를 찾지 못해 너무 멀리 이동시키면, a값이 한 점으로 모이지 않고 반대편으로 튀며 치솟습니다. 그래서 어느 만큼 이동할지를 신중히 정해야 하는데, 이 이동 거리를 정해 주는 값이 학습률입니다.

⚠️ 학습률이 너무 작을 때도 문제
학습률이 너무 작으면 한 번에 아주 조금씩만 움직이므로 최적점까지 가는 데 시간이 너무 오래 걸립니다(느린 수렴). 또 오차 그래프에 골짜기가 여러 개 있는 복잡한 모델에서는, 가장 깊은 골짜기가 아닌 얕은 골짜기(지역 최솟값, local minimum)에 빠진 뒤 빠져나오지 못할 위험도 커집니다. 이번 예제처럼 오차 그래프가 포물선 하나라면 지역 최솟값 문제는 없고, 느려지는 문제만 생깁니다. 학습률은 너무 크면 발산, 너무 작으면 느린 수렴으로 세트로 기억하세요.

✓ 학습률 찾기도 최적화의 일부
최적의 학습률을 찾는 것은 딥러닝에서 중요한 최적화 과정 중 하나입니다. 1주차 수학에서 본 "새 가중치 = 현재 가중치 − 학습률 × 기울기"가 바로 이 과정입니다.

❌ 시험 함정 — 경사 하강법이 찾는 지점과 정하는 값
경사 하강법은 오차의 변화에 따라 이차 함수 그래프를 만들고, 적절한 학습률을 설정해서 미분 값이 0인 지점을 구하는 것입니다. 찾는 곳은 기울기가 0인 꼭짓점이고, 사람이 정해 주는 값은 임의의 값이 아니라 학습률입니다.

07 미리 보기 — 파이썬으로 경사 하강법 돌려 보기

강의노트 개념을 코드로 확인 (심화)

강의노트 3강은 경사 하강법의 개념까지 다룹니다. 개념이 실제로 어떻게 움직이는지 보기 위해, 기울기 a와 y절편 b를 0에서 시작해 경사 하강법으로 고쳐 나가는 코드를 직접 만들어 실행해 보았습니다.

📖 심화 — a와 b를 동시에 고치려면 편미분
오차(MSE)는 a와 b 두 변수의 함수이므로, 1주차에서 배운 편미분으로 각각의 기울기를 구합니다.
· a에 대한 기울기 : ∂MSE/∂a = −(2/n) Σ x(y − ŷ)
· b에 대한 기울기 : ∂MSE/∂b = −(2/n) Σ (y − ŷ)
그리고 새 값 = 현재 값 − 학습률 × 기울기로 a와 b를 동시에 업데이트합니다.
※ 앞의 마이너스(−)는 오차를 실제 − 예측(y − ŷ)으로 정의했기 때문에 붙습니다. MSE를 a로 미분하면 체인 룰에 따라 (y − ŷ)의 속미분 −x가 곱해지기 때문입니다. 교재에 따라 오차를 예측 − 실제(ŷ − y)로 정의하면 같은 식이 ∂MSE/∂a = (2/n) Σ x(ŷ − y)로 마이너스 없이 쓰이며, 두 식은 완전히 같은 값입니다.

경사 하강법으로 a와 b 찾기 (학습률 0.03)

a, b = 0, 0 # 기울기와 절편을 0에서 시작
lr = 0.03 # 학습률
epochs = 2001 # 반복 횟수
n = len(x)

for i in range(epochs):
    y_pred = a * x + b
    error = y - y_pred # 오차 = 실제 - 예측 (y - y_pred) 기준
    a_diff = -(2 / n) * sum(x * error) # a에 대한 편미분
    b_diff = -(2 / n) * sum(error) # b에 대한 편미분
    a = a - lr * a_diff # 기울기 반대 방향으로 이동
    b = b - lr * b_diff
    if i % 400 == 0:
        print(f"epoch={i}, 기울기={a:.4f}, 절편={b:.4f}, MSE={mse(a, b):.4f}")

▶ 실행 결과 (lr = 0.03, epochs = 2001)

epoch=0, 기울기=27.8400, 절편=5.4300, MSE=6199.8149
epoch=400, 기울기=2.5542, 절편=77.4830, MSE=8.6836
epoch=800, 기울기=2.3051, 절편=78.9696, MSE=8.3002
epoch=1200, 기울기=2.3001, 절편=78.9994, MSE=8.3000
epoch=1600, 기울기=2.3000, 절편=79.0000, MSE=8.3000
epoch=2000, 기울기=2.3000, 절편=79.0000, MSE=8.3000

처음에는 MSE가 6,000이 넘었지만, 반복할수록 오차가 줄어 기울기 2.3, 절편 79, MSE 8.3에 도착합니다. 공식 없이 "먼저 긋고 수정하기"만으로 3주차 최소 제곱법과 같은 답을 찾은 것입니다.

학습률을 바꾸면? (0.001 vs 0.03 vs 0.06)

for lr in [0.001, 0.03, 0.06]:
    a, b = 0, 0
    for i in range(100):
        error = y - (a * x + b)
        a = a - lr * (-(2 / n) * sum(x * error))
        b = b - lr * (-(2 / n) * sum(error))
    print(f"학습률 {lr} → 100번 후 기울기 {a:.4g}, 절편 {b:.4g}")

▶ 실행 결과 (각 학습률로 100번 반복)

학습률 0.001 → 100번 후 기울기 14.68, 절편 4.969
학습률 0.03 → 100번 후 기울기 7.121, 절편 50.23
학습률 0.06 → 100번 후 기울기 -2.111e+44, 절편 -3.537e+43

⚠️ 너무 작은 학습률과 너무 큰 학습률
학습률 0.001은 100번을 반복해도 절편이 겨우 4.969로, 답(79)까지 한참 멀었습니다. 너무 작은 학습률의 느린 수렴입니다. 학습률 0.03은 100번 반복한 시점에 아직 답(2.3, 79)을 향해 가는 중이지만, 학습률을 0.06으로 두 배만 키워도 기울기가 −2.111 × 10⁴⁴라는 터무니없는 값으로 발산합니다. 강의노트의 "너무 멀리 이동시키면 a값이 한 점으로 모이지 않고 치솟는다"는 설명이 바로 이 현상입니다.

08 핵심 정리

시험 직전에 이것만은 꼭

📌 핵심 정리

· 최소 제곱법의 단점 : 여러 개의 입력 처리에 무리 → "일단 그리고 조금씩 수정해 나가기" 방식
· 평균 제곱 오차(MSE) : 주어진 선의 오차를 평가하는 방법. 나중에 그린 선이 더 좋은지 판단하는 기준
· 오차 : 실제 값과 예측 값의 차이. 오차가 작을수록 잘 그어진 예측선
· 제곱하는 이유 : 그냥 더하면 +와 −가 지워짐 (1 + (−5) + 3 + 3 = 2) → 제곱합 44
· MSE 공식 : (1/n) Σ (y − ŷ)², 예제(y = 3x + 76) → 44 ÷ 4 = 11
· MSE 방식의 목표 : 임의의 직선을 그어 MSE를 구하고, MSE를 가장 작게 만드는 a와 b를 찾기
· 기울기 a와 오차 : 이차 함수 관계, 오차 최소 지점 m = 포물선의 꼭짓점 (미분 값 0)
· 경사 하강법 : a₁에서 미분 → 기울기 반대 방향으로 이동(+면 음의 방향, −면 양의 방향) → 미분 값이 0이 아니면 반복
· 학습률 : 이동 거리를 정하는 값. 너무 크면 a값이 한 점으로 모이지 않고 치솟음(발산), 너무 작으면 느린 수렴. 최적 학습률 찾기도 최적화 과정
· 경사 하강법 정의 : 오차 변화에 따른 이차 함수 그래프 + 적절한 학습률 → 미분 값이 0인 지점 찾기

태그 : 평균 제곱 오차 MSE란MSE 공식 계산오차를 제곱하는 이유파이썬 MSE 코드경사 하강법이란학습률 learning rate경사 하강법 미분 기울기선형회귀 먼저 긋고 수정하기최소제곱법 한계파이썬 경사 하강법 구현

출처 : 이 글은 부산디지털대학교(BDU)의 '파이썬 기반의 AI프로그래밍' 과목 2026년도 강의노트를 참고하여 학습용으로 작성한 글입니다.

📚 부산디지털대학교 '파이썬 기반의 AI프로그래밍' 3주차 강의노트와 직접 실습한 코랩 노트를 바탕으로 정리한 학습 노트입니다. (출처는 글 하단 참고)

01 선형 회귀 — 성적은 무엇에 따라 달라질까

독립 변수와 종속 변수

"학생들의 중간고사 성적이 다 다르다." 이 문장은 너무 당연해서 알려 주는 정보가 거의 없습니다. 그런데 문장을 이렇게 바꾸면 이야기가 달라집니다.

학생들의 중간고사 성적이 [ 정보 ]에 따라 다 다르다.
[ ] 안에 시험 성적을 좌우할 만한 정보가 들어가면 훨씬 많은 사실을 알 수 있음

[ ] 안에 들어갈 정보가 정확할수록 성적을 예측하는 방정식을 만들 수 있습니다. 이때 성적을 변하게 하는 정보를 x, x에 따라 변하는 성적을 y라고 합니다.

단순 선형 회귀 vs 다중 선형 회귀

02 가장 훌륭한 예측선

점들의 특징을 가장 잘 담은 직선 하나

성적을 결정하는 여러 요소 중 공부한 시간 하나만 골라 단순 선형 회귀를 해 보겠습니다. 학생 4명의 데이터는 다음과 같습니다.

이 점들을 좌표에 찍어 보면 왼쪽 아래에서 오른쪽 위로 향하는, 직선으로 나타낼 만한 형태(선형)가 보입니다. 이 점들의 특징을 담은 직선은 1주차에서 배운 일차함수 모양입니다.

y = ax + b
x : 독립 변수(공부 시간)  |  y : 종속 변수(성적)  |  a : 기울기  |  b : y절편

📖 훌륭한 예측선이란?
· 주어진 점들의 특징을 가장 잘 담은, 제대로 된 선을 긋는 작업
· 정확하게 계산하려면 상수 a(기울기)와 b(y절편)의 값을 정확히 알아야 함
· 선의 방향을 잘 정하면, 그 선을 따라가는 것만으로 지금은 보이지 않는 미래의 값을 예측할 수 있음

딥러닝과 선형 회귀의 관계

딥러닝은 자그마한 통계의 결과들이 무수히 얽히고설켜 이루어지는 복잡한 연산의 결정체입니다. 그 가장 말단에서 이루어지는 기본 계산 원리는 단 두 가지입니다.

📖 심화 — 2주차 뉴런과 연결해 보기
2주차에서 배운 뉴런의 계산 y = f(wx + b)에서 w를 a로 바꾸면 선형 회귀의 y = ax + b와 같은 모양입니다. 여기에 1주차의 시그모이드를 씌워 0~1 사이 확률로 바꾼 것이 로지스틱 회귀입니다. 그래서 선형 회귀를 이해하면 딥러닝 뉴런 하나가 무엇을 하는지 이해한 셈입니다.

❌ 시험 함정 — 선형 회귀의 핵심은 "선의 방향"
선형 회귀는 예측을 수행하는 가장 기본 알고리즘입니다. 선의 방향을 잘 정하고 그 선을 따라가면 더 정확한 예측을 할 수 있다는 것이 선형 회귀의 개념입니다. 학습정리의 두 가지 구분, 즉 독립 변수 개수에 따른 단순 선형 회귀와 다중 선형 회귀도 함께 기억하세요.

03 최소 제곱법이란?

오차를 제곱해서 더한 값이 가장 작은 선

점 4개를 지나는 직선은 무수히 많이 그릴 수 있습니다. 그중 어떤 선이 "가장 훌륭한" 선일까요? 그 기준을 정해 주는 것이 최소 제곱법입니다.

📖 최소 제곱법 (method of least squares)
· 다른 이름 : 최소자승법, 최소제곱근사법, 최소자승근사법 (least squares approximation)
· 어떤 계(system)의 해방정식을 근사적으로 구하는 방법
· 근사적으로 구하려는 해와 실제 해의 오차의 제곱의 합(SS)이 최소가 되는 해를 구하는 방법
※ SS는 제곱합(Sum of Squares) 일반을 뜻하는 약자이고, 회귀 분석에서 오차의 제곱합은 보통 SSE(Sum of Squared Errors, 오차 제곱합) 또는 RSS(Residual Sum of Squares, 잔차 제곱합)라고 부릅니다. 섹션 07 코드의 sse() 함수가 바로 이 값입니다.

✓ 왜 그냥 더하지 않고 제곱할까?
어떤 점은 선보다 위(+), 어떤 점은 아래(−)에 있습니다. 오차를 그냥 더하면 +와 −가 서로 지워져 0에 가까워지므로 선이 좋은지 나쁜지 알 수 없습니다. 제곱하면 모두 양수가 되고, 큰 오차일수록 더 크게 반영되어 공정하게 비교할 수 있습니다.

📖 심화 — 직선이 아니어도 된다
강의노트의 그래프처럼 최소 제곱법은 직선뿐 아니라 2차 곡선 같은 다른 형태에도 쓸 수 있습니다. "방정식의 형태를 알고 있을 때 상수 값을 추정한다"는 정의가 바로 이 뜻입니다. 정해 둔 형태 안에서 오차 제곱합이 가장 작은 상수를 찾는 것입니다.

04 최소 제곱법 손으로 풀어 보기

공부 시간과 성적 데이터로 a와 b 구하기

STEP 1 · 공식

a = Σ(x − x)(y − y) ÷ Σ(x − x)²
(x − x 평균)(y − y 평균)의 합 ÷ (x − x 평균)²의 합

📖 공식 읽는 법
· 편차 : 각 값에서 평균을 뺀 값 (x − x)
· 분모 : x의 편차를 제곱해서 모두 더한 값
· 분자 : x의 편차와 y의 편차를 곱해서 모두 더한 값
· x(엑스 바)는 x의 평균, y(와이 바)는 y의 평균을 뜻하는 기호

STEP 2 · 평균 구하기

STEP 3 · 편차 표로 분모와 분자 구하기

a = 46 ÷ 20 = 2.3

📖 보충 — 기울기는 2.4가 아니라 2.3
강의노트의 기울기 계산식 마지막 줄에는 결과가 "= 2.4"로 적혀 있습니다. 같은 식을 계산하면 분자 46, 분모 20이므로 46 ÷ 20 = 2.3이 맞습니다. 강의노트도 바로 다음 단계인 b 계산과 최종 방정식(y = 2.3x + 79)에서는 2.3을 사용하고 있고, 3강 파이썬 실습 결과도 2.3입니다. 2.4는 표기 오류로 보면 됩니다.

STEP 4 · y절편 b 구하기

b = y − (x × a)
y의 평균에서 x의 평균과 기울기의 곱을 빼면 b

b = 90.5 − (5 × 2.3) = 90.5 − 11.5 = 79

STEP 5 · 예측 방정식 완성

y = 2.3x + 79

❌ 시험 함정 — 최소 제곱법으로 구하는 두 값
최소 제곱법이라는 공식을 알면 기울기 a와 정확한 y절편 b를 구해 예측을 수행할 수 있습니다. 순서도 중요합니다. 먼저 a를 구하고, 그 a를 넣어 b = y − x·a를 계산합니다.

05 내 코랩 실습 — 파이썬으로 최소 제곱법

직접 실행한 코드와 결과 그대로

3강 실습 코드를 코랩에서 셀 단위로 나눠 직접 실행했습니다. 아래 코드와 실행 결과는 제 코랩 노트(최소제곱법_실습.ipynb)에 있는 그대로입니다.

① 라이브러리 불러오기 · 데이터 준비 · 평균 계산

#최소제곱법 실습
import numpy as np

x = np.array([2,4,6,8]) #공부한 시간
y = np.array([81,93,91,97]) #학습 점수

#mean() 함수 사용: 평균 계산
mx = np.mean(x) #공부한 시간 평균
my = np.mean(y) #학습 점수 평균
print("x 평균:", mx)
print("y 평균:", my)

▶ 실행 결과 (코랩 실행)

x 평균: 5.0
y 평균: 90.5

② 분모 — x 편차 제곱의 합

#최소제곱법 공식
#a = (x-x평균)(y-y평균)의 합 / (x-x평균)^2 합
divisor = sum([(i-mx)**2 for i in x])
#sum 함수 사용
#i라는 기본 요소 x에서 평균 빼고, **2 제곱 처리
print("divisor = ", divisor)

▶ 실행 결과 (코랩 실행)

divisor =  20.0

✓ [(i-mx)**2 for i in x] 는 무엇?
리스트 컴프리헨션(list comprehension)이라는 파이썬 문법입니다. x의 원소를 하나씩 i로 꺼내 (i − 평균)²을 계산한 값을 리스트로 모읍니다. [9.0, 1.0, 1.0, 9.0]이 만들어지고, sum()이 이를 더해 20.0이 됩니다.

③ 분자 — x 편차 × y 편차의 합 (top 함수)

def top(x, mx, y, mv):
  d = 0
  for i in range(len(x)):
    d += (x[i]-mx)*(y[i]-my) #+= 연산자, 복합 연산자는 하나가 아닌 2개 이상의 연산자의 결합 형태
    #+= 연산자는 A += b 경우 A = A+b
  return d

dividend = top(x, mx, y, my)
print("dividend = ", dividend)

print("분모 : ", divisor)
print("분자 : ", dividend)

▶ 실행 결과 (코랩 실행)

dividend =  46.0
분모 :  20.0
분자 :  46.0

⚠️ 실습하며 발견한 점 — 매개변수 이름 mv
제 코드에서 함수 정의가 def top(x, mx, y, mv)로 되어 있는데, 함수 안에서는 my를 쓰고 있습니다. 그래도 결과가 맞게 나온 이유는 함수 밖에서 만든 전역 변수 my(90.5)를 함수가 대신 읽었기 때문입니다. 파이썬은 변수 이름을 지역(Local) → 바깥 함수(Enclosing) → 전역(Global) → 내장(Built-in) 순서로 찾는데(LEGB 규칙), 함수 안에 my라는 지역 변수가 없으니 전역의 my까지 찾아간 것입니다. 지금은 우연히 맞았지만, 다른 데이터로 top()을 호출하면 엉뚱한 평균이 쓰일 수 있습니다. 매개변수 이름을 def top(x, mx, y, my)로 고쳐야 함수가 넘겨받은 값을 정확히 사용합니다.

④ 기울기 a

a = dividend / divisor
print("기울기 a = :", a)

▶ 실행 결과 (코랩 실행)

기울기 a = : 2.3

⑤ y절편 b

b = my - (mx * a)
print("y의 절편 b = ", b)

▶ 실행 결과 (코랩 실행)

y의 절편 b =  79.0

손으로 푼 값과 똑같이 a = 2.3, b = 79.0이 나왔습니다. 따라서 예측 방정식은 y = 2.3x + 79입니다.

📖 보충 — 코드 주석의 "분산"과 "공분산"
강의노트 코드 주석은 분모를 "x의 분산", 분자를 "x와 y의 공분산"이라고 설명합니다. 엄밀히 말하면 분산과 공분산은 이 합을 데이터 개수 n으로 나눈 값(평균)이고, 코드가 계산하는 것은 나누기 전의 편차 제곱합과 편차 곱의 합입니다. 다만 기울기는 분자 ÷ 분모라서 위아래의 n이 서로 지워지므로, "공분산 ÷ 분산"으로 구해도 결과(2.3)는 같습니다.

06 NumPy — 수학 연산을 도와주는 라이브러리

반복문 없이 배열 전체를 한 번에 계산

실습 코드의 첫 줄 import numpy as np는 NumPy(넘파이) 라이브러리를 np라는 짧은 이름으로 불러오는 코드입니다. NumPy는 파이썬에서 과학적 계산을 위한 핵심 라이브러리로, 다차원 배열과 다양한 수치 연산 기능을 제공하며 대규모 데이터를 효율적으로 처리하도록 설계되었습니다.

벡터화 연산을 쓰면 for 문으로 만든 top() 함수 없이도 분자와 분모를 한 줄씩으로 계산할 수 있습니다.

벡터화 연산으로 다시 쓴 최소 제곱법

import numpy as np

x = np.array([2, 4, 6, 8])
y = np.array([81, 93, 91, 97])
mx, my = np.mean(x), np.mean(y)

a = np.sum((x - mx) * (y - my)) / np.sum((x - mx) ** 2) # 반복문 없이 배열 전체 계산
b = my - mx * a
print("기울기 a =", a)
print("y절편 b =", b)

▶ 실행 결과 (x = [2, 4, 6, 8], y = [81, 93, 91, 97])

기울기 a = 2.3
y절편 b = 79.0

NumPy에는 최소 제곱법으로 직선을 맞춰 주는 np.polyfit() 함수도 있습니다. 직접 구한 값이 맞는지 검산할 때 유용합니다.

np.polyfit()으로 검산하기

a, b = np.polyfit(x, y, 1) # 1 = 1차식(직선) y = ax + b로 맞추기
print("기울기 a =", round(a, 2))
print("y절편 b =", round(b, 2))

▶ 실행 결과 (위 코드에 이어서 실행)

기울기 a = 2.3
y절편 b = 79.0

✓ 참고 — 최신 NumPy 권장 방식 Polynomial.fit
NumPy 공식 문서는 np.polyfit을 예전 다항식 API로 분류하고, 새 코드에는 수치적으로 더 안정적인 numpy.polynomial.Polynomial.fit을 권장합니다. 다만 간단한 직선 검산이나 입문 교재에서는 np.polyfit이 여전히 가장 널리 쓰이므로 둘 다 알아 두면 좋습니다.

Polynomial.fit으로 같은 결과 얻기

from numpy.polynomial import Polynomial

p = Polynomial.fit(x, y, 1).convert() # convert(): 원래 x 단위의 계수로 변환
b, a = p.coef # 계수가 낮은 차수부터 [b, a] 순서
print("기울기 a =", round(a, 2))
print("y절편 b =", round(b, 2))

▶ 실행 결과 (위 코드에 이어서 실행)

기울기 a = 2.3
y절편 b = 79.0

❌ 시험 함정 — 수학 연산 라이브러리는 NumPy
파이썬 라이브러리 중 수학 연산과 분석을 도와주는 라이브러리는 NumPy입니다. TensorFlow는 2주차에서 본 것처럼 딥러닝 모델(층)을 만들고 학습시키는 딥러닝 프레임워크이므로 헷갈리지 마세요.

📖 보충 — NumPy는 외부 라이브러리
강의노트 해설은 NumPy를 "표준 라이브러리 중 하나"라고 설명하지만, 2주차에서 정리했듯 NumPy는 파이썬과 함께 설치되는 표준 라이브러리가 아니라 따로 설치하는 외부(서드파티) 라이브러리입니다. 코랩에는 미리 설치되어 있어 바로 import할 수 있을 뿐입니다.
(근거: Python 공식 문서 「The Python Standard Library」 — 표준 라이브러리 목록에 NumPy 없음)

07 예측선으로 미래 예측하고 오차 확인하기

정말 이 선이 "가장 훌륭한" 선일까?

y = 2.3x + 79로 성적 예측하기

a, b = 2.3, 79
for hour in x:
    print(f"{hour}시간 공부 → 예측 점수 {a * hour + b:.1f}")
print(f"7시간 공부 → 예측 점수 {a * 7 + b:.1f}") # 데이터에 없는 값 예측

▶ 실행 결과 (a = 2.3, b = 79)

2시간 공부 → 예측 점수 83.6
4시간 공부 → 예측 점수 88.2
6시간 공부 → 예측 점수 92.8
8시간 공부 → 예측 점수 97.4
7시간 공부 → 예측 점수 95.1

데이터에 없던 7시간을 넣어도 예측 점수(95.1점)를 바로 얻을 수 있습니다. 이것이 "선을 따라가면 보이지 않는 미래 값을 예측할 수 있다"는 말의 의미입니다.

이번에는 최소 제곱법의 정의대로 오차 제곱합을 직접 계산해, 다른 직선들과 비교해 보겠습니다.

직선별 오차 제곱합(SS) 비교

def sse(a, b):
    y_pred = a * x + b # 예측값
    return np.sum((y - y_pred) ** 2) # 오차 제곱합

print(f"a=2.3, b=79.0 → 오차 제곱합 {sse(2.3, 79.0):.2f}")
print(f"a=2.4, b=78.5 → 오차 제곱합 {sse(2.4, 78.5):.2f}")
print(f"a=2.0, b=80.5 → 오차 제곱합 {sse(2.0, 80.5):.2f}")

▶ 실행 결과 (세 직선 비교)

a=2.3, b=79.0 → 오차 제곱합 33.20
a=2.4, b=78.5 → 오차 제곱합 33.40
a=2.0, b=80.5 → 오차 제곱합 35.00

✓ 최소 제곱법의 의미를 숫자로 확인
세 직선 모두 평균점 (5, 90.5)을 지나지만, 오차 제곱합이 가장 작은 것은 최소 제곱법으로 구한 y = 2.3x + 79입니다. 공식이 "오차 제곱합이 최소가 되는 a와 b"를 정확히 찾아 준다는 것을 확인할 수 있습니다. 4주차에서는 이렇게 오차를 줄여 가며 선을 찾는 방법을 더 배우게 됩니다.

08 핵심 정리

시험 직전에 이것만은 꼭

📌 핵심 정리

· 독립 변수 x : 독립적으로 변하는 값(정보, 입력) / 종속 변수 y : x에 따라 변하는 값(성적, 출력)
· 단순 선형 회귀 : x가 하나 / 다중 선형 회귀 : x가 여러 개(x₁, x₂, x₃ …)
· 훌륭한 예측선 : 제대로 된 선을 긋는 작업. 선의 방향을 잘 정하면 보이지 않는 미래 값 예측 가능
· 선형 회귀의 목표 : y = ax + b에서 최적의 a(기울기)와 b(y절편) 찾기
· 딥러닝의 말단 두 원리 : 선형 회귀 + 로지스틱 회귀
· 최소 제곱법 : 오차의 제곱의 합(SS)이 최소가 되는 해를 구하는 방법. 값을 정확히 측정할 수 없을 때, 방정식 형태를 알고 상수를 추정할 때 사용
· 기울기 공식 : a = Σ(x − x)(y − y) ÷ Σ(x − x)² (분자 = 편차 곱의 합, 분모 = x 편차 제곱합)
· y절편 공식 : b = y − x·a (a를 먼저 구한 뒤 계산)
· 예제 결과 : x = 5, y = 90.5, 분자 46, 분모 20 → a = 2.3, b = 79 → y = 2.3x + 79
· NumPy : 수학 연산·분석 라이브러리(TensorFlow 아님). ndarray, 벡터화 연산, np.mean() 등 수학 함수

태그 : 선형회귀란단순 선형회귀 다중 선형회귀 차이독립변수 종속변수 차이최소제곱법 공식최소제곱법 기울기 y절편 구하기파이썬 최소제곱법 코드넘파이 mean 평균오차 제곱합 SSEnumpy polyfit 선형회귀훌륭한 예측선

출처 : 이 글은 부산디지털대학교(BDU)의 '파이썬 기반의 AI프로그래밍' 과목 2026년도 강의노트를 참고하여 학습용으로 작성한 글입니다.