콘텐츠로 이동
교육자료

AI 기초 › 06장

선형 분류와 정규화

읽기 1시간 30분 · 실습 1시간 30분인쇄용 보기(PDF)

05장에서는 로지스틱 회귀를 “확률을 내는 모델”로만 빌려 쓰고, make_pipeline(StandardScaler(), ...)으로 표준화를 함께 묶으면서 왜 표준화가 필요한지는 미뤘다. 이 장은 그 안을 연다. 04장의 선형 회귀가 낸 숫자를 시그모이드로 0~1 확률로 바꾸면 로지스틱 회귀가 되고, 손실을 로그 손실로 바꾸면 04장과 같은 경사하강법으로 학습된다. 그다음 계수가 너무 커지는 과적합을 정규화로 누르고, 정규화가 왜 스케일링을 요구하는지 본다. 로지스틱 회귀는 표 데이터 분류에서 가장 먼저 세우는 기준선이고, 10장의 신경망 마지막 층도 같은 구조다.

목표 완료 기준
선형 점수와 확률을 잇는다 decision_function(z)에 시그모이드를 씌우면 predict_proba가 됨을 코드로 확인한다
계수를 읽는다 coef_의 부호와 크기를 오즈(odds)로 해석한다
결정 경계를 그린다 특성 2개에서 경계가 직선인 이유와, 임계값을 바꾸면 경계가 평행 이동함을 말한다
로그 손실을 계산한다 로그 손실을 직접 계산해 log_loss와 맞추고, 제곱 오차 대신 쓰는 이유를 말한다
직접 학습한다 경사하강법으로 로지스틱 회귀를 NumPy로 구현해 sklearn과 비교한다
여러 범주를 다룬다 소프트맥스로 범주별 확률을 만들고 coef_의 모양을 읽는다
정규화를 쓴다 L2·L1의 차이와 C의 방향(작을수록 강함)을 말하고, 검증·교차검증으로 C를 고른다
스케일링을 지킨다 정규화·수렴 때문에 스케일링이 필요한 이유를 말하고 파이프라인으로 묶는다
선택 기준표에 줄을 더한다 선형 분류·정규화를 언제 고르는지 적는다
실습 노트북 06을 끝낸다 실습/문제/ch06_선형_분류와_정규화.ipynb의 점검 셀이 모두 “통과”를 출력한다

예상 시간: 원고 1시간 30분, 실습 1시간 30분.

  • 분류의 기준선이다. 학습이 빠르고, 하이퍼파라미터가 사실상 C 하나이며, 확률을 낸다. 표 데이터 분류에서는 이 모델로 먼저 점수를 내 두고, 더 복잡한 모델(7장 트리·앙상블)이 그 점수를 넘는지 본다.
  • 설명할 수 있다. 특성마다 계수가 하나라 “어느 특성이 어느 쪽으로 얼마나 밀었나”를 말할 수 있다. 대출 심사처럼 이유를 설명해야 하는 곳에서 쓴다.
  • 딥러닝으로 이어진다. 신경망의 분류 층은 “선형 점수 → 시그모이드·소프트맥스 → 교차 엔트로피 손실”이고, 이것이 이 장의 로지스틱 회귀 그대로다(10·11장).

05장과 같은 유방암 데이터(악성 1), 같은 분할, 같은 특성 2개를 쓴다. 표준화한 특성을 Xs_tr·Xs_va라 부른다.

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
bc = load_breast_cancer(as_frame=True)
y = (bc.target == 0).astype(int).to_numpy() # 악성 1, 양성 0
cols = ["mean texture", "mean smoothness"]
X = bc.data[cols].to_numpy()
X_tmp, X_te, y_tmp, y_te = train_test_split(X, y, test_size=0.2, stratify=y, random_state=0)
X_tr, X_va, y_tr, y_va = train_test_split(X_tmp, y_tmp, test_size=0.25, stratify=y_tmp, random_state=0)
scaler = StandardScaler().fit(X_tr)
Xs_tr, Xs_va = scaler.transform(X_tr), scaler.transform(X_va)
clf = LogisticRegression().fit(Xs_tr, y_tr)
w, b = clf.coef_[0], clf.intercept_[0]
print(clf.coef_.shape, w.round(3), round(b, 3))
z = Xs_va @ w + b # 04장 선형 회귀와 같은 식
print(np.allclose(z, clf.decision_function(Xs_va)), z[:4].round(3))
출력
(1, 2) [1.112 1.285] -0.751
True [-3.495 -2.256 1.802 -2.289]

로지스틱 회귀도 먼저 04장 선형 회귀처럼 선형 점수 z=w1x1+w2x2+bz = w_1 x_1 + w_2 x_2 + b를 계산한다. sklearn에서는 decision_function이 이 zz를 돌려준다. zz는 −∞-\infty부터 +∞+\infty까지 어떤 값이든 될 수 있어서 그대로는 확률이 아니다.

이 장부터 지수와 로그가 나온다. e≈2.718e \approx 2.718은 자연상수이고, eze^z(np.exp(z))는 zz가 1 늘 때마다 ee배가 된다. 이 장의 log⁡\log는 밑이 ee인 자연로그(np.log)이며 eze^z의 역함수다. 즉 log⁡ez=z\log e^z = z이고, log⁡(ab)=log⁡a+log⁡b\log(ab) = \log a + \log b라서 곱을 합으로 바꾼다(6-5절 수학 상자).

zz를 0~1로 눌러 담는 함수가 시그모이드(sigmoid, 로지스틱 함수)다.

σ(z)=11+e−z\sigma(z) = \frac{1}{1 + e^{-z}}

def sigmoid(z):
return 1 / (1 + np.exp(-z))
for v in [-6, -2, 0, 2, 6]:
print(v, round(sigmoid(v), 3))
p_va = sigmoid(z)
print(np.allclose(p_va, clf.predict_proba(Xs_va)[:, 1]))
출력
-6 0.002
-2 0.119
0 0.5
2 0.881
6 0.998
True
  • z=0z = 0이면 0.5, zz가 클수록 1에, 작을수록 0에 가깝다. zz가 ±6만 돼도 거의 0이나 1이다.
  • 로지스틱 회귀 = 선형 점수 + 시그모이드. predict_proba[:, 1]은 σ(z)\sigma(z) 그대로다. 그래서 이름에 “회귀”가 남았다. 선형 회귀처럼 점수를 내고, 그 점수를 확률로 바꾼다.
  • 위 sigmoid는 zz가 아주 작으면(예: −1000) np.exp(-z)가 넘쳐 경고를 낸다. 실무에서는 scipy.special.expit처럼 안정하게 만든 함수를 쓴다(실습 문제 2).

확률 pp 대신 오즈(odds) p/(1−p)p / (1 - p)로 보면 계수가 깔끔해진다. 오즈는 “1일 가능성이 0일 가능성의 몇 배인가”다(p=0.8p = 0.8이면 4). 시그모이드를 거꾸로 풀면

log⁡p1−p=z=w1x1+w2x2+b\log \frac{p}{1 - p} = z = w_1 x_1 + w_2 x_2 + b

즉 로그 오즈가 특성의 선형식이다. x1x_1이 1 늘면 로그 오즈가 w1w_1만큼 늘고, 오즈는 ew1e^{w_1}배가 된다.

for name, wi in zip(cols, w):
print(f"{name}: 계수 {wi:.3f}, 표준편차 1 증가 → 오즈 {np.exp(wi):.2f}배")
x_mean = np.zeros((1, 2)) # 표준화 공간의 0 = 훈련 평균
x_up = np.array([[1.0, 0.0]]) # 질감만 표준편차 1 증가
odds = lambda p: p / (1 - p)
p0, p1 = clf.predict_proba(x_mean)[0, 1], clf.predict_proba(x_up)[0, 1]
print(round(p0, 3), round(p1, 3), round(odds(p1) / odds(p0), 2))
출력
mean texture: 계수 1.112, 표준편차 1 증가 → 오즈 3.04배
mean smoothness: 계수 1.285, 표준편차 1 증가 → 오즈 3.62배
0.321 0.589 3.04
  • 계수가 양수면 그 특성이 클수록 악성 쪽, 음수면 양성 쪽으로 민다. 두 특성 모두 양수다.
  • 특성을 표준화했으므로 계수는 “표준편차 1만큼”의 효과이고, 특성끼리 크기를 비교할 수 있다. 표준화하지 않으면 계수는 원래 단위(질감 1, 매끄러움 0.01 같은) 기준이라 크기 비교가 안 된다.
  • 오즈는 늘 같은 배수로 변하지만, 확률이 늘어나는 양은 출발점에 따라 다르다(위에서 0.321 → 0.589, 0.27 늘었다). 확률로 말할 때는 “어디서 출발했나”를 함께 말한다.
  • 계수는 다른 특성을 고정했을 때의 효과다. 특성끼리 강하게 얽혀 있으면(예: 반지름과 넓이) 계수의 부호와 크기가 불안정해서 해석에 조심한다. 이것도 정규화가 필요한 이유 중 하나다(6-7절).

시그모이드는 늘 증가하므로 p≥0.5  ⟺  z≥0p \ge 0.5 \iff z \ge 0이다. 특성 2개에서 z=w1x1+w2x2+b=0z = w_1 x_1 + w_2 x_2 + b = 0은 직선이다. 단, w1w_1과 w2w_2가 모두 0이면 zz가 상수라 경계가 생기지 않는다. 이 직선을 결정 경계(decision boundary)라 한다. 직선 한쪽은 1, 다른 쪽은 0으로 예측한다.

임계값 tt(0<t<10 < t < 1)를 쓰면 p≥t  ⟺  z≥log⁡t1−tp \ge t \iff z \ge \log \dfrac{t}{1 - t}이다. 오른쪽 값을 로짓(logit)이라 하며 시그모이드의 역함수다. 임계값을 바꾸면 기울기(ww)는 그대로이고 상수만 바뀌므로 경계가 평행 이동한다.

def logit(t):
return np.log(t / (1 - t))
for t in [0.3, 0.5, 0.7]:
same = np.array_equal(p_va >= t, z >= logit(t))
print(f"임계값 {t}: z 기준 {logit(t):+.3f}, 같은 예측 {same}, 1 예측 {(z >= logit(t)).sum()}명")
출력
임계값 0.3: z 기준 -0.847, 같은 예측 True, 1 예측 58명
임계값 0.5: z 기준 +0.000, 같은 예측 True, 1 예측 38명
임계값 0.7: z 기준 +0.847, 같은 예측 True, 1 예측 24명
시그모이드는 z = 0에서 0.5를 지나고, 임계값별 결정 경계는 평행한 직선이며, 제곱 특성을 더하면 경계가 원에 가까운 곡선이 된다시그모이드는 z = 0에서 0.5를 지나고, 임계값별 결정 경계는 평행한 직선이며, 제곱 특성을 더하면 경계가 원에 가까운 곡선이 된다

그림 설명. 왼쪽은 가로축 선형 점수 zz(−7~7), 세로축 확률 pp(0~1)의 시그모이드 곡선이다. z=0z = 0에서 0.5를 지나고, 점선은 임계값 0.3·0.5·0.7이 zz −0.85·0·+0.85에 대응함을 보인다. 가운데는 검증 데이터 114명을 질감(가로)과 매끄러움(세로, 둘 다 표준화)으로 찍은 것이다. 양성(0)은 회색 점, 악성(1)은 빨간 삼각형이며 악성이 오른쪽 위에 많다. 오른쪽 아래로 내려가는 평행한 직선 셋이 경계다. 실선이 임계값 0.5, 왼쪽 아래 점선이 0.3, 오른쪽 위 점선이 0.7이다. 오른쪽은 원 데이터의 훈련 210개다. 안쪽 원의 빨간 삼각형이 1, 바깥 고리의 회색 점이 0이다. 원래 특성 2개로 학습한 경계는 가운데를 비스듬히 가르는 점선 직선이고, 제곱 특성을 더한 경계는 안쪽 원을 감싸는, 원에 가까운 파란 타원이다.

  • 그림 가운데의 세 직선은 임계값 0.3·0.5·0.7의 경계다. 모두 평행하다. 임계값을 낮추면 경계가 0 쪽으로 밀려 1 영역이 넓어진다(05장에서 재현율이 오른 이유).
  • 특성이 3개면 경계는 평면, 그 이상이면 초평면(hyperplane)이다. 특성이 몇 개든 ”zz = 상수”인 평평한 경계 하나가 공간을 둘로 나눈다. 그래서 선형 분류기(linear classifier)라 부른다.

직선으로 못 나누면 특성을 더한다

섹션 제목: “직선으로 못 나누면 특성을 더한다”

안쪽 원은 1, 바깥 고리는 0인 데이터는 어떤 직선으로도 나눌 수 없다.

from sklearn.datasets import make_circles
from sklearn.preprocessing import PolynomialFeatures
Xc, yc = make_circles(n_samples=300, factor=0.5, noise=0.1, random_state=0)
c_tr, c_va, yc_tr, yc_va = train_test_split(Xc, yc, test_size=0.3, stratify=yc, random_state=0)
lin = LogisticRegression().fit(c_tr, yc_tr)
print("원래 특성 2개:", round(lin.score(c_va, yc_va), 3))
poly = PolynomialFeatures(2, include_bias=False).fit(c_tr) # x1, x2, x1², x1·x2, x2²
print(poly.get_feature_names_out())
quad = LogisticRegression().fit(poly.transform(c_tr), yc_tr)
print("제곱 특성 추가:", round(quad.score(poly.transform(c_va), yc_va), 3))
출력
원래 특성 2개: 0.433
['x0' 'x1' 'x0^2' 'x0 x1' 'x1^2']
제곱 특성 추가: 0.978
  • score는 분류에서 정확도다. 직선 경계는 절반도 못 맞혔지만, x12x_1^2·x22x_2^2를 더하자 거의 다 맞혔다. z=w3x12+w5x22+⋯z = w_3 x_1^2 + w_5 x_2^2 + \cdots가 0인 곳을 원래 평면에 그리면 이차곡선 경계가 되고, 이 데이터에서는 원에 가까운 타원이 되기 때문이다(그림 맨 오른쪽).
  • 모델은 여전히 “특성에 대해 선형”이다. 휘어진 경계는 특성을 늘려서 얻었다. 05장 다항 회귀와 같은 방법이다.
  • 특성을 늘리면 계수가 많아져 과적합하기 쉽다. 그래서 특성을 늘릴 때는 정규화(6-7절)를 함께 쓴다. 어떤 특성을 만들어야 할지 모르면 트리(7장)나 신경망(10장)처럼 경계 모양을 스스로 찾는 모델을 쓴다.

04장 선형 회귀는 평균 제곱 오차를 줄였다. 로지스틱 회귀는 로그 손실(log loss), 다른 이름으로 이진 교차 엔트로피(binary cross-entropy)를 줄인다. 표본 하나의 손실은

  • 정답이 1이면 −log⁡p-\log p, 정답이 0이면 −log⁡(1−p)-\log(1 - p)
  • 한 줄로: −[ ylog⁡p+(1−y)log⁡(1−p) ]-[\,y \log p + (1 - y) \log(1 - p)\,]

이고, 전체는 그 평균이다. 정답 쪽에 준 확률이 1에 가까우면 손실이 0에 가깝고, 0에 가까우면 손실이 끝없이 커진다.

from sklearn.metrics import log_loss
for p in [0.99, 0.9, 0.5, 0.1, 0.01]:
print(f"정답 1, p = {p}: 손실 {-np.log(p):.3f}")
def bce(y, p):
return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
print(round(bce(y_va, p_va), 4), round(log_loss(y_va, p_va), 4))
출력
정답 1, p = 0.99: 손실 0.010
정답 1, p = 0.9: 손실 0.105
정답 1, p = 0.5: 손실 0.693
정답 1, p = 0.1: 손실 2.303
정답 1, p = 0.01: 손실 4.605
0.4044 0.4044
  • 확신하고 틀릴수록(정답 1에 p=0.01p = 0.01) 손실이 크다. 그래서 로그 손실은 정확도와 달리 확률이 얼마나 믿을 만한지까지 잰다. 이 장에서는 정규화의 효과를 볼 때 검증 로그 손실을 쓴다.
  • pp가 정확히 0이나 1이면 log⁡0=−∞\log 0 = -\infty가 된다. sklearn log_loss는 확률을 아주 작은 값 안쪽으로 잘라(clip) 계산한다. 직접 계산할 때도 np.clip(p, 1e-15, 1 - 1e-15)처럼 자른다(실습 문제 4).

시그모이드 출력에 제곱 오차를 쓰면, 확신하고 틀린 표본에서 기울기가 거의 0이 되어 학습이 멈춘다. zz에 대한 기울기를 비교해 본다.

for zz in [-4.6, 0.0, 4.6]: # 정답이 1인 표본의 z
p = sigmoid(zz)
g_mse = 2 * (p - 1) * p * (1 - p) # d(p − 1)² / dz
g_log = p - 1 # d(−log p) / dz
print(f"z {zz:+.1f}, p {p:.3f}: 제곱 오차 기울기 {g_mse:+.4f}, 로그 손실 기울기 {g_log:+.4f}")
출력
z -4.6, p 0.010: 제곱 오차 기울기 -0.0195, 로그 손실 기울기 -0.9900
z +0.0, p 0.500: 제곱 오차 기울기 -0.2500, 로그 손실 기울기 -0.5000
z +4.6, p 0.990: 제곱 오차 기울기 -0.0002, 로그 손실 기울기 -0.0100

정답이 1인데 p=0.01p = 0.01로 크게 틀린 표본(z=−4.6z = -4.6)에서 제곱 오차의 기울기는 −0.02뿐이다. 시그모이드의 기울기 p(1−p)p(1 - p)가 곱해져 작아지기 때문이다. 로그 손실은 그 항이 약분되어 기울기가 p−y=−0.99p - y = -0.99로 크다. 틀린 만큼 세게 고친다. 또 로그 손실은 ww에 대해 볼록(convex)이라, 경사하강법이 멈춘 곳(지역 최솟값)이 곧 가장 낮은 곳(전역 최솟값)이다. 다만 최솟값이 하나뿐이라거나 유한한 계수에서 반드시 도달한다는 보장은 아니다. 특성이 중복되면 다른 계수가 같은 손실을 낼 수 있고, 데이터가 직선으로 완전히 나뉘면 계수가 끝없이 커진다(6-7절).

로그 손실의 기울기는 04장 선형 회귀와 모양이 같다. 예측이 y^=Xw+b\hat{y} = Xw + b에서 p=σ(Xw+b)p = \sigma(Xw + b)로 바뀌었을 뿐이다.

∂L∂w=1NX⊤(p−y),∂L∂b=1N∑i(pi−yi)\frac{\partial L}{\partial w} = \frac{1}{N} X^\top (p - y), \qquad \frac{\partial L}{\partial b} = \frac{1}{N} \sum_i (p_i - y_i)

def fit_logistic(X, y, lr=0.5, steps=3000):
w, b = np.zeros(X.shape[1]), 0.0
for _ in range(steps):
p = sigmoid(X @ w + b)
w -= lr * X.T @ (p - y) / len(y)
b -= lr * np.mean(p - y)
return w, b
w_gd, b_gd = fit_logistic(Xs_tr, y_tr)
ref = LogisticRegression(C=np.inf).fit(Xs_tr, y_tr) # 정규화 없음
print(w_gd.round(4), round(b_gd, 4))
print(ref.coef_[0].round(4), round(ref.intercept_[0], 4))
print("훈련 로그 손실", round(bce(y_tr, sigmoid(Xs_tr @ w_gd + b_gd)), 4))
출력
[1.1568 1.3396] -0.7668
[1.1565 1.3396] -0.7668
훈련 로그 손실 0.4714
  • 정규화를 끈(C=np.inf) sklearn 결과와 계수 차이가 0.001 미만이다. sklearn은 같은 손실을 경사하강법보다 빠른 방법(기본 lbfgs)으로 줄일 뿐이다.
  • 6-3절의 clf(기본 C=1.0)와 계수가 조금 다른 것은 기본값에 L2 정규화가 들어 있기 때문이다(6-7절).
  • 예전 코드의 penalty 인자(penalty=None, penalty="l1" 등)는 scikit-learn 1.8부터 사용 중단(deprecated) 경고가 나고 1.10에서 없어질 예정이다. 정규화를 끌 때는 penalty=None 대신 C=np.inf, L1은 l1_ratio=1을 쓴다. 이 자료는 1.9.0 기준으로 C와 l1_ratio만 쓴다.

수학 상자: 시그모이드와 로그우도

섹션 제목: “수학 상자: 시그모이드와 로그우도”

시그모이드의 성질. σ(−z)=1−σ(z)\sigma(-z) = 1 - \sigma(z)이고, 미분은 σ′(z)=σ(z) (1−σ(z))\sigma'(z) = \sigma(z)\,(1 - \sigma(z))이다. 미분이 가장 큰 곳은 z=0z = 0(값 0.25)이고 ∣z∣\lvert z \rvert가 크면 0에 가깝다. 앞의 제곱 오차 기울기에 붙은 p(1−p)p(1 - p)가 이것이다.

로그우도에서 로그 손실로. 모델이 표본 ii에 정답 yiy_i를 낼 확률은 pi yi(1−pi)1−yip_i^{\,y_i} (1 - p_i)^{1 - y_i}이다(yi=1y_i = 1이면 pip_i, 0이면 1−pi1 - p_i). 표본이 서로 독립이면 데이터 전체가 나올 확률, 즉 우도(likelihood)는 이것들의 곱이다. 우도를 가장 크게 하는 ww를 고르는 것이 최대우도 추정(maximum likelihood estimation)이다. 곱은 다루기 어려우니 로그를 씌워 합(로그우도)으로 만들고, 부호를 바꿔 평균하면 로그 손실이 된다.

p_tr = sigmoid(Xs_tr @ w_gd + b_gd)
lik = np.prod(np.where(y_tr == 1, p_tr, 1 - p_tr)) # 우도: 정답 쪽 확률의 곱
loglik = np.sum(y_tr * np.log(p_tr) + (1 - y_tr) * np.log(1 - p_tr)) # 로그우도: 로그의 합
print(f"{lik:.3e}", round(np.log(lik), 3), round(loglik, 3), round(-loglik / len(y_tr), 4))
출력
1.526e-70 -160.759 -160.759 0.4714
  • 우도는 0에 아주 가까운 수라 표본이 더 많으면 컴퓨터가 0으로 처리한다(언더플로). 로그를 씌우면 −160.8 같은 다룰 만한 수가 된다.
  • −로그우도 / N이 앞의 훈련 로그 손실과 같다. 로그 손실을 줄이기 = 우도를 키우기다. 10장 이후 딥러닝의 분류 손실도 같은 원리다.

6-6. 범주가 셋 이상일 때: 소프트맥스

섹션 제목: “6-6. 범주가 셋 이상일 때: 소프트맥스”

범주가 KK개면 범주마다 선형 점수 z1,…,zKz_1, \dots, z_K를 계산하고, 소프트맥스(softmax)로 합이 1인 확률로 바꾼다.

pk=ezkez1+⋯+ezKp_k = \frac{e^{z_k}}{e^{z_1} + \cdots + e^{z_K}}

붓꽃(iris) 데이터(특성 4개, 품종 3개)로 확인한다.

from sklearn.datasets import load_iris
iris = load_iris()
Xi_tr, Xi_va, yi_tr, yi_va = train_test_split(iris.data, iris.target, test_size=0.3, stratify=iris.target, random_state=0)
sc_i = StandardScaler().fit(Xi_tr)
multi = LogisticRegression().fit(sc_i.transform(Xi_tr), yi_tr)
print(multi.classes_, multi.coef_.shape, multi.intercept_.shape)
Zi = multi.decision_function(sc_i.transform(Xi_va)) # (N, 3): 범주별 점수
P = np.exp(Zi) / np.exp(Zi).sum(axis=1, keepdims=True)
print(np.allclose(P, multi.predict_proba(sc_i.transform(Xi_va))), P[:2].round(3))
print(np.array_equal(P.argmax(axis=1), multi.predict(sc_i.transform(Xi_va))), round(multi.score(sc_i.transform(Xi_va), yi_va), 3))
출력
[0 1 2] (3, 4) (3,)
True [[0. 0.036 0.964]
[0.001 0.234 0.764]]
True 0.978
  • coef_의 모양이 (범주 수, 특성 수)다. 범주마다 자기 점수를 내는 선형식이 하나씩 있다. 이진 분류는 (1, 특성 수) 하나뿐이었다(1의 점수만 계산하고 0은 1−p1 - p).
  • 예측은 확률이 가장 큰 범주다(argmax). 소프트맥스는 순서를 바꾸지 않으므로 점수 zkz_k가 가장 큰 범주와 같다. 손실은 정답 범주 확률의 −log, 즉 교차 엔트로피(cross-entropy)다. 이진 로그 손실은 그 K=2K = 2인 경우다.
  • 소프트맥스는 14장 어텐션과 16장 LLM의 다음 토큰 확률에 다시 나온다. 큰 점수에서 넘침을 막는 계산법은 그때 다룬다.

정규화 없이 학습하면 모델은 훈련 데이터의 로그 손실을 끝까지 줄이려 한다. 특성이 많으면 계수를 크게 키워 훈련 데이터의 잡음이나 우연한 패턴까지 맞히고, 데이터가 직선으로 완전히 나뉘면 계수가 끝없이 커진다(확률을 0과 1로 밀어붙이려고). 그러면 처음 보는 데이터에서 확신하고 틀리는 일이 늘어 검증 손실이 커질 수 있다. 계수가 크다는 것만으로 과적합이라 단정하지는 않는다. 과적합인지는 검증 결과로 판단한다.

정규화(regularization)는 손실에 계수 크기에 대한 벌점을 더한다.

이름 벌점 효과 sklearn
L2(릿지, ridge) 계수 제곱합 12∥w∥22=12∑jwj2\tfrac{1}{2}\lVert w \rVert_2^2 = \tfrac{1}{2} \sum_j w_j^2 계수 전체의 크기를 0 쪽으로 누른다. 개별 계수가 모두 같은 비율로 줄지는 않는다 기본값(l1_ratio=0)
L1(라쏘, lasso) 계수 절댓값 합 ∥w∥1=∑j∣wj∣\lVert w \rVert_1 = \sum_j \lvert w_j \rvert 쓸모 적은 계수를 정확히 0으로 만든다 l1_ratio=1, solver="liblinear" 또는 "saga"

sklearn은 “C × (로그 손실 합) + 벌점”을 줄인다. 그래서 C는 정규화 강도의 역수다. C가 작을수록 벌점이 상대적으로 커져 정규화가 강하고, C=np.inf면 정규화가 없다. 절편 bb에는 벌점을 주지 않는다(liblinear는 예외, 아래 참고).

특성 30개 전부를 쓴다. 05장 5-8절처럼 30개면 거의 다 맞히지만, 정규화를 아주 약하게 하면 검증에서 무너지는 모습을 본다.

X30 = bc.data.to_numpy()
X30_tmp, X30_te, _, _ = train_test_split(X30, y, test_size=0.2, stratify=y, random_state=0)
X30_tr, X30_va, _, _ = train_test_split(X30_tmp, y_tmp, test_size=0.25, stratify=y_tmp, random_state=0) # 같은 환자 분할
sc30 = StandardScaler().fit(X30_tr)
A_tr, A_va = sc30.transform(X30_tr), sc30.transform(X30_va)
print(" C |w|합 훈련손실 검증손실 검증정확도 L1 0 아닌 계수")
for C in [0.01, 0.1, 1, 10, 100, 10000]:
m2 = LogisticRegression(C=C, max_iter=5000).fit(A_tr, y_tr)
m1 = LogisticRegression(C=C, l1_ratio=1, solver="liblinear", random_state=0).fit(A_tr, y_tr)
pt, pv = m2.predict_proba(A_tr)[:, 1], m2.predict_proba(A_va)[:, 1]
print(f"{C:>5g} {np.abs(m2.coef_).sum():6.1f} {log_loss(y_tr, pt):8.3f} {log_loss(y_va, pv):8.3f}"
f" {m2.score(A_va, y_va):9.3f} {np.count_nonzero(m1.coef_):8d}")
출력
C |w|합 훈련손실 검증손실 검증정확도 L1 0 아닌 계수
0.01 3.6 0.189 0.169 0.947 2
0.1 8.1 0.094 0.076 0.982 8
1 15.8 0.056 0.043 0.991 16
10 39.8 0.033 0.053 0.982 24
100 112.1 0.014 0.128 0.947 23
10000 507.2 0.001 0.747 0.930 30
C가 커질수록 L2 계수는 함께 벌어지고, L1 계수는 0에서 하나씩 살아나며, 검증 로그 손실은 C 약 2에서 가장 낮고 그 뒤로 오른다C가 커질수록 L2 계수는 함께 벌어지고, L1 계수는 0에서 하나씩 살아나며, 검증 로그 손실은 C 약 2에서 가장 낮고 그 뒤로 오른다

그림 설명. 세 그림 모두 가로축이 C(0.01~10000, 로그 눈금)다. 왼쪽은 L2, 가운데는 L1에서 특성 30개의 계수(세로, −25~25)가 C에 따라 어떻게 변하는지 선 30개로 그렸다. L2는 작은 C에서 모든 계수가 0 근처에 모여 있다가 C가 커지면서 함께 벌어지고, 큰 C에서는 일부가 세로 범위 밖으로 나간다. L1은 작은 C에서 대부분의 선이 정확히 0에 붙어 있고, C가 커지면서 0에서 떨어지는 선이 늘어난다. 오른쪽은 L2 모델의 로그 손실(세로)이다. 훈련 손실(흰색·검은색 선)은 C가 커질수록 0까지 계속 내려간다. 검증 손실(초록)은 C 약 1.8에서 약 0.04로 가장 낮고(빨간 원), 그 뒤로 올라가 C 10000에서 약 0.75가 된다. 왼쪽 끝에는 “과소적합”, 오른쪽 끝에는 “과적합”이라고 적었다.

  • C를 키울수록(정규화를 약하게) 계수 크기의 합이 커지고 훈련 손실은 계속 줄어든다. 05장의 다항식 차수처럼 C도 모델 복잡도의 손잡이다.
  • 검증 손실은 C=1 근처에서 가장 작고, C=10000에서는 훈련 손실이 거의 0인데 검증 손실이 크게 늘었다. 과적합이다. C=0.01은 계수를 너무 눌러 훈련·검증 모두 손실이 크다. 과소적합이다.
  • L1은 C가 작을수록 0인 계수가 대체로 많다. C=0.01에서 30개 중 2개만 남았다. 남은 특성만 봐도 되므로 특성 선택과 해석에 쓴다. liblinear는 계산 순서에 난수를 쓰므로 random_state를 고정해야 0 아닌 계수의 개수가 실행마다 같다(고정하지 않았을 때 이 PC에서 7과 8이 번갈아 나왔다). 특성끼리 얽혀 있으면 L1은 그중 하나만 남기고 나머지를 0으로 만드는 경향이 있어서, 어느 것이 남았는지를 “중요한 특성 목록”으로 단정하지는 않는다.
  • solver="liblinear"는 절편에도 벌점을 준다(intercept_scaling으로 조절). 표준화해도 이 벌점은 없어지지 않고, 정규화가 강할수록(C가 작을수록) 절편이 0 쪽으로 눌려 확률이 달라질 수 있다. 이 장에서는 0이 되는 계수 개수를 보는 L1 예시에만 쓴다. 절편에 벌점이 없는 L1이 필요하면 solver="saga"를 쓰되, 수렴이 느리므로 max_iter를 늘린다.

C는 학습이 정하지 않는 하이퍼파라미터다. 05장의 규칙대로 검증 데이터나 교차검증으로 고른다. 로그 간격(0.01, 0.1, 1, …)으로 후보를 둔다. 결과가 10배씩 달라지는 손잡이이기 때문이다.

from sklearn.pipeline import make_pipeline
from sklearn.model_selection import StratifiedKFold, cross_val_score
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
for C in [0.01, 0.1, 1, 10, 100]:
pipe = make_pipeline(StandardScaler(), LogisticRegression(C=C, max_iter=5000))
s = -cross_val_score(pipe, X30_tmp, y_tmp, cv=cv, scoring="neg_log_loss")
print(f"C {C:>5g}: 교차검증 로그 손실 {s.mean():.3f} ± {s.std(ddof=1):.3f}")
출력
C 0.01: 교차검증 로그 손실 0.190 ± 0.027
C 0.1: 교차검증 로그 손실 0.101 ± 0.030
C 1: 교차검증 로그 손실 0.088 ± 0.055
C 10: 교차검증 로그 손실 0.147 ± 0.117
C 100: 교차검증 로그 손실 0.308 ± 0.178
  • 훈련+검증 455명(X30_tmp)에서 5-겹 교차검증을 했다. 스케일러는 파이프라인 안에 있어 조각마다 훈련 부분으로만 fit된다(05장 5-9절).
  • C 0.1~1이 가장 좋고, 둘의 차이는 조각 간 흔들림보다 작다. 이럴 때는 더 단순한 쪽(정규화가 강한 작은 C)을 고르는 것도 합리적이다.
  • scoring을 무엇으로 하느냐에 따라 고른 C가 달라질 수 있다. 확률 자체를 쓸 거면 로그 손실, 순위만 쓸 거면 AUC, 정해진 채점 지표가 있으면 그 지표로 고른다.
  • LogisticRegressionCV는 이 반복을 내장한 클래스다. 쓰는 법은 9장 하이퍼파라미터 탐색에서 GridSearchCV와 함께 다룬다.

벌점 ∑jwj2\sum_j w_j^2은 모든 계수를 같은 잣대로 누른다. 그런데 계수의 크기는 특성의 단위에 달려 있다. 넓이를 mm² 대신 100배 큰 단위로 적으면 값이 1/100로 작아지고, 같은 효과를 내려면 계수는 100배 커져야 한다. 그러면 벌점도 커져 그 특성만 더 세게 눌린다. 단위만 바꿨는데 모델이 달라진다.

area = list(bc.feature_names).index("mean area")
X30_tr_u, X30_va_u = X30_tr.copy(), X30_va.copy()
X30_tr_u[:, area] /= 100 # 같은 정보, 단위만 바꿈
X30_va_u[:, area] /= 100
raw_a = LogisticRegression(max_iter=10000).fit(X30_tr, y_tr).predict_proba(X30_va)[:, 1]
raw_b = LogisticRegression(max_iter=10000).fit(X30_tr_u, y_tr).predict_proba(X30_va_u)[:, 1]
pipe_a = make_pipeline(StandardScaler(), LogisticRegression()).fit(X30_tr, y_tr).predict_proba(X30_va)[:, 1]
pipe_b = make_pipeline(StandardScaler(), LogisticRegression()).fit(X30_tr_u, y_tr).predict_proba(X30_va_u)[:, 1]
print("스케일링 없음: 확률 최대 차이", round(np.abs(raw_a - raw_b).max(), 3))
print("표준화 후 : 확률 최대 차이", round(np.abs(pipe_a - pipe_b).max(), 6))
출력
스케일링 없음: 확률 최대 차이 0.132
표준화 후 : 확률 최대 차이 0.0

표준화하면 어떤 단위로 적었든 평균 0·표준편차 1이 되므로 같은 모델이 나온다. 정규화를 쓰는 선형 모델에는 스케일링이 사실상 필수다. sklearn 로지스틱 회귀는 기본이 L2 정규화이므로, 아무 설정 없이 써도 이 문제가 생긴다.

특성 크기가 제각각이면 손실 곡면이 한 방향으로 길게 늘어나 최적화가 오래 걸린다(04장 학습률 실험에서 걸음이 바닥 양쪽을 오가던 것과 같은 현상).

import warnings
from sklearn.exceptions import ConvergenceWarning
with warnings.catch_warnings(record=True) as caught:
warnings.simplefilter("always")
raw = LogisticRegression().fit(X30_tr, y_tr) # 기본 max_iter=100
print("스케일링 없음:", raw.n_iter_, [c.category.__name__ for c in caught], round(raw.score(X30_va, y_va), 3))
scaled = make_pipeline(StandardScaler(), LogisticRegression()).fit(X30_tr, y_tr)
print("표준화 후 :", scaled[-1].n_iter_, round(scaled.score(X30_va, y_va), 3))
출력
스케일링 없음: [100] ['ConvergenceWarning'] 0.965
표준화 후 : [18] 0.991
  • 표준화하지 않으면 반복 100번 안에 끝나지 못해 ConvergenceWarning이 나고, 덜 학습된 모델의 정확도도 낮다. 표준화하면 20번 안쪽에서 끝난다.
  • 이 경고가 나면 먼저 스케일링을 확인한다. max_iter만 키워 경고를 없애면 단위 때문에 생긴 정규화 차이는 그대로 남는다. 스케일링한 뒤에도 반복 상한에 걸리면 그때 max_iter를 늘려 수렴하는지 본다.
  • 스케일러는 05장 규칙대로 훈련 데이터로만 fit한다. make_pipeline(StandardScaler(), LogisticRegression(...))으로 묶으면 교차검증·예측에서도 자동으로 지켜진다. 05장에서 이 묶음을 쓴 이유다.

6-9. 선형 회귀의 정규화: 릿지와 라쏘

섹션 제목: “6-9. 선형 회귀의 정규화: 릿지와 라쏘”

같은 벌점을 04장 선형 회귀에 붙이면 릿지(Ridge, L2)와 라쏘(Lasso, L1)가 된다. 여기서는 강도 손잡이가 alpha이고 클수록 강하다. 로지스틱 회귀의 C와 방향이 반대다.

from sklearn.datasets import load_diabetes
from sklearn.linear_model import LinearRegression, Ridge, Lasso
dia = load_diabetes()
Xd = StandardScaler().fit_transform(dia.data) # 계수 크기만 비교하는 예라 전체로 표준화
print("선형 회귀 |w|합", round(np.abs(LinearRegression().fit(Xd, dia.target).coef_).sum(), 1))
for a in [0.1, 1, 10]:
r, l = Ridge(alpha=a).fit(Xd, dia.target), Lasso(alpha=a).fit(Xd, dia.target)
print(f"alpha {a:>4}: 릿지 |w|합 {np.abs(r.coef_).sum():6.1f} / 라쏘 0 아닌 계수 {np.count_nonzero(l.coef_)}개")
출력
선형 회귀 |w|합 164.6
alpha 0.1: 릿지 |w|합 162.0 / 라쏘 0 아닌 계수 9개
alpha 1: 릿지 |w|합 143.7 / 라쏘 0 아닌 계수 7개
alpha 10: 릿지 |w|합 105.0 / 라쏘 0 아닌 계수 4개
  • alpha를 키우면 릿지는 계수 크기를 전체적으로 줄이고, 라쏘는 0인 계수를 늘린다. 로지스틱 회귀의 L2·L1과 같은 모습이다.
  • 이 코드는 평가 없이 계수 모양만 보려고 전체 데이터로 표준화했다. 점수를 잴 때는 05장처럼 나눈 뒤 훈련 데이터로만 fit한다.
  • 이름 정리: “정규화 강도”를 sklearn은 로지스틱 회귀·SVM에서는 C(역수, 작을수록 강함), 릿지·라쏘에서는 alpha(클수록 강함)로 받는다. 신경망에서도 계수(가중치)를 작게 누르는 가중치 감쇠(weight decay)를 쓴다(11장). 기본 경사하강법에서는 L2 벌점을 더하는 것과 같은 효과지만, AdamW 같은 일부 최적화 방법의 가중치 감쇠는 L2 벌점과 계산이 달라 구별한다.
상황 선형 분류(로지스틱 회귀) 다른 선택
표 데이터, 처음 시작 기준선으로 먼저 세운다 7장 트리·앙상블과 비교
이유를 설명해야 한다(대출·의료) 계수·오즈로 설명. L1로 특성을 줄이면 더 쉽다 트리 하나(7장)
표본보다 특성이 많다(텍스트 단어 수만 개) 정규화한 선형 모델이 강하다
경계가 휘었다, 특성 사이 상호작용이 크다 특성을 직접 만들어야 한다(제곱·곱) 트리·앙상블(7장), 신경망(10장)
이미지·소리·문장 원본 원본 픽셀에는 약하다 CNN·트랜스포머(12·14장). 사전학습 모델이 뽑은 특성 + 로지스틱 헤드(15장)
잘 맞는 확률이 필요하다 로그 손실로 학습해 확률이 대체로 무난하다(검증에서 확인)

15장에서 사전학습 모델이 뽑은 특성 위에 얹는 “가벼운 분류기”도 이 장의 로지스틱 회귀다.

상황 고를 것 이유 장
표 데이터 분류를 시작한다 make_pipeline(StandardScaler(), LogisticRegression())으로 기준선 빠르고 확률을 내며 계수로 설명할 수 있다. 더 복잡한 모델은 이 점수를 넘어야 한다 06
선형 모델에 정규화를 쓴다 먼저 스케일링(파이프라인 안), C·alpha는 로그 간격 후보를 교차검증으로 벌점이 단위를 타고, 강도는 10배 단위로 효과가 달라진다 06
특성이 많고 쓸모 있는 것은 일부다 L1(l1_ratio=1) 또는 라쏘 쓸모 적은 계수를 0으로 만들어 특성을 고르고 해석을 쉽게 한다 06
경계가 직선이 아니다 특성 추가(제곱·곱) + 정규화, 또는 트리·신경망 선형 모델은 특성에 대해서만 선형이다 06

11문항. 풀면 결과가 기록되고 복습 일정에 들어간다.

문제 1 · 결과 예측

계수가 w=(2,−1)w = (2, -1), 절편이 b=0.5b = 0.5인 로지스틱 회귀에 x=(1,3)x = (1, 3)을 넣는다. 아래 코드의 출력은?

import numpy as np
w, b = np.array([2.0, -1.0]), 0.5
x = np.array([1.0, 3.0])
z = x @ w + b
print(z, round(1 / (1 + np.exp(-z)), 3))
보기
정답과 해설

정답: 3번

z=2⋅1+(−1)⋅3+0.5=−0.5z = 2 \cdot 1 + (-1) \cdot 3 + 0.5 = -0.5이고, σ(−0.5)=1−σ(0.5)≈0.378\sigma(-0.5) = 1 - \sigma(0.5) \approx 0.378이다. zz가 음수이므로 확률은 0.5보다 작고, 임계값 0.5라면 0으로 예측한다.

오답 해설: 0.5 0.622는 zz의 부호를 거꾸로 계산한 답이다. −1.5는 절편을 더하지 않고 뺀 값이다(2−3−0.52 - 3 - 0.5). −0.5에 0.622를 붙인 답은 σ(−z)\sigma(-z), 즉 0일 확률을 계산했다.

문제 2 · 객관식

표준화한 두 특성 A, B로 학습한 로지스틱 회귀의 계수가 A 1.2, B −0.3이다. 옳은 해석은?

보기
정답과 해설

정답: 1번

계수는 다른 특성을 고정했을 때의 효과이고, 오즈는 e1.2≈3.32e^{1.2} \approx 3.32배가 된다. 표준화했으므로 "표준편차 1만큼"의 효과로 읽는다.

오답 해설: 확률은 일정한 배수로 변하지 않는다. 늘어나는 양이 출발점에 따라 다르다. B는 계수가 음수라 클수록 0 쪽으로 민다. 특성끼리 강하게 얽혀 있으면 계수의 부호와 크기가 불안정해서 해석에 조심해야 한다.

문제 3 · 빈칸

특성 2개 로지스틱 회귀의 계수가 w1=1w_1 = 1, w2=2w_2 = 2, 절편이 b=−4b = -4다. 임계값 0.5의 결정 경계가 x1=0x_1 = 0인 세로축과 만나는 점의 x2x_2 값은 ____이다.

정답과 해설

정답: 2

임계값 0.5의 경계는 z=0z = 0, 즉 x1+2x2−4=0x_1 + 2x_2 - 4 = 0인 직선이다. x1=0x_1 = 0을 넣으면 2x2=42x_2 = 4, x2=2x_2 = 2다.

문제 4 · O/X

두 모델 A, B가 같은 표본들을 모두 맞혔다(정확도가 같다). 모든 표본에서 각각 A가 정답 쪽에 준 확률이 B보다 낮다면, A의 로그 손실이 B보다 크다.

보기
정답과 해설

정답: O (참)

정확도는 임계값 기준으로 맞았는지만 세지만, 로그 손실은 표본마다 정답 쪽 확률 pp의 −log⁡p-\log p를 평균한다. −log⁡p-\log p는 pp가 낮을수록 커지므로 모든 표본에서 A의 항이 더 크고, 평균도 더 크다. 표본마다가 아니라 평균 확률만 낮은 경우에는 반드시 그렇지는 않다.

문제 5 · 객관식

시그모이드 출력으로 학습할 때 제곱 오차 대신 로그 손실을 쓰는 이유로 맞는 것은?

보기
정답과 해설

정답: 2번

제곱 오차의 zz에 대한 기울기에는 시그모이드의 기울기 p(1−p)p(1 - p)가 곱해져, p=0.01p = 0.01로 크게 틀린 표본에서도 −0.02 정도로 작다. 로그 손실은 그 항이 약분되어 p−y=−0.99p - y = -0.99로 크다. 틀린 만큼 세게 고친다.

오답 해설: 제곱 오차는 0·1 정답에도 계산은 된다. 문제는 기울기다. 로그 손실은 볼록이라 지역 최솟값이 전역 최솟값이지만, 최솟값이 하나뿐이거나 유한한 계수에서 도달한다는 보장은 없다(데이터가 완전히 나뉘면 계수가 끝없이 커진다). 로그 손실은 확률을 반올림하지 않는다. 0이나 1 바로 근처에서 log가 무한대가 되지 않게 아주 작은 값 안쪽으로 자를 뿐이다.

문제 6 · 결과 예측

아래 코드의 출력은?

import numpy as np
y = np.array([1, 0, 1])
p = np.array([0.8, 0.4, 0.5])
lik = np.prod(np.where(y == 1, p, 1 - p))
print(round(lik, 3), round(-np.log(lik) / len(y), 3))
보기
정답과 해설

정답: 4번

정답 쪽 확률은 0.8, 1−0.4=0.61 - 0.4 = 0.6, 0.5이고 그 곱(우도)은 0.24다. −log⁡0.24≈1.427-\log 0.24 \approx 1.427을 표본 수 3으로 나눈 0.476이 이 세 표본의 로그 손실이다.

오답 해설: 0.16은 정답이 0인 표본에도 pp(0.4)를 그대로 곱한 값이다. 1.427은 NN으로 나누지 않은 −로그우도다. 0.76은 1−1 - 우도로, 의미 없는 값이다.

문제 7 · 객관식

범주 3개 로지스틱 회귀가 한 표본에 낸 점수(decision_function)가 (1.5, 3.0, −0.5)(1.5,\ 3.0,\ -0.5)다. 옳은 것은?

보기
정답과 해설

정답: 1번

소프트맥스는 점수의 순서를 바꾸지 않으므로 확률이 가장 큰 범주는 점수가 가장 큰 둘째 범주다.

오답 해설: 소프트맥스는 ezke^{z_k}를 그 합으로 나누므로 점수 부호와 관계없이 확률 합이 늘 1이다. e−0.5e^{-0.5}는 0보다 크므로 세 번째 범주 확률도 0이 아니다. 확률 비는 점수 비가 아니라 e1.5:e3.0e^{1.5} : e^{3.0}, 즉 약 1 대 4.5다.

문제 8 · 객관식

특성 30개 L2 로지스틱 회귀에서 C=1의 훈련·검증 로그 손실은 0.056·0.043, C=10000은 0.001·0.747이었다. 옳은 해석은?

보기
정답과 해설

정답: 3번

C가 클수록 정규화가 약하다. C=10000은 훈련 손실을 거의 0까지 줄였지만 검증 손실이 크게 늘었다. 과적합이다. C는 검증 손실(또는 교차검증)로 고른다.

오답 해설: 정규화가 너무 강해 생기는 과소적합은 C=0.01 쪽이다. 훈련 손실만으로 고르면 검증 성능이 나빠지는 것을 놓쳐 과적합한 모델을 고를 수 있다. 이 예에서는 C=10000이 그렇다. 정확도가 비슷해도 검증 로그 손실이 0.043 대 0.747이면 C=10000 모델은 확신하고 틀리는 일이 많다는 뜻이라 같은 모델로 볼 수 없다.

문제 9 · O/X

L1 정규화 로지스틱 회귀에서 0이 아닌 계수로 남은 특성들은 그 데이터의 "중요한 특성 목록"이라고 단정해도 된다.

보기
정답과 해설

정답: X (거짓)

특성끼리 얽혀 있으면 L1은 그중 하나만 남기고 나머지를 0으로 만드는 경향이 있다. 0이 된 특성도 남은 특성과 거의 같은 정보를 담고 있을 수 있으므로, 남은 목록을 중요도 순위로 단정하지 않는다.

문제 10 · 결과 예측

아래 코드의 출력은? 둘째 열은 첫째 열의 단위만 100배 큰 단위로 바꾼 것이다.

import numpy as np
from sklearn.preprocessing import StandardScaler
a = np.array([[100.0], [200.0], [300.0]])
print(StandardScaler().fit_transform(a).ravel().round(3).tolist(),
      StandardScaler().fit_transform(a / 100).ravel().round(3).tolist())
보기
정답과 해설

정답: 1번

표준화는 평균을 빼고 표준편차로 나누므로, 단위를 바꿔도 결과가 같다. StandardScaler는 NN으로 나눈 표준편차(약 81.65)를 쓰므로 양 끝은 ±100/81.65≈±1.225\pm 100 / 81.65 \approx \pm 1.225다. 그래서 표준화한 뒤에 학습하면 단위와 상관없이 같은 모델이 나온다.

오답 해설: 둘째 결과가 1/100로 작아진다고 본 답은 표준화가 단위를 없앤다는 점을 놓쳤다. ±1.0은 N−1N - 1로 나눈 표준편차(100)를 쓴 값이다. ±100은 평균만 빼고 표준편차로 나누지 않은 값이다.

문제 11 · 객관식

고객 이탈 여부를 맞히는 표 데이터 분류를 새로 시작한다. 특성은 40개이고, 결과의 이유를 설명해야 한다. 첫 모델로 가장 알맞은 것은?

보기
정답과 해설

정답: 4번

표 데이터 분류는 표준화 + 로지스틱 회귀로 기준선을 먼저 세운다. 빠르고 확률을 내며 계수로 설명할 수 있다. C는 로그 간격 후보를 교차검증으로 고르고, 스케일러는 파이프라인 안에 둔다.

오답 해설: 원래 단위의 계수는 단위에 따라 크기가 달라 특성끼리 비교할 수 없고, 정규화를 끄면 계수가 불안정해질 수 있다. L1로 남은 특성은 얽힌 특성 중 하나만 남은 결과일 수 있어 "중요 특성"으로 단정하지 않는다. 제곱·곱 특성을 모두 더하면 특성이 800개 넘게 늘어나는데 정규화까지 끄면 과적합하기 쉽다. 특성을 늘릴 때는 정규화를 함께 쓴다.

실습/문제/ch06_선형_분류와_정규화.ipynb를 .venv 커널로 열고 위에서부터 푼다. 내려받기가 없고 CPU로 1분 안에 끝난다. 다 푼 뒤 해설 노트북과 비교한다.

번호 유형 내용
1 개념 시그모이드·로지스틱 회귀 참/거짓
2 코드 넘침 없는 시그모이드
3 코드 coef_·intercept_로 predict_proba 직접 계산
4 코드 로그 손실 직접 계산(확률 자르기 포함)
5 코드 경사하강법 로지스틱 회귀(L2 포함)
6 코드 임계값별 결정 경계 직선
7 코드 교차검증으로 C 고르기
8 개념 정규화·스케일링 참/거짓
9 사례 계수 해석이 이상한 대출 모델 진단
10 사례 상황별 모델·설정 고르기