지식
AI

로지스틱 회귀: 분류 문제의 첫 걸음

시그모이드 함수, BCE 손실, 결정 경계, 소프트맥스 다중 분류까지 로지스틱 회귀의 원리와 scikit-learn·PyTorch 구현을 완전 정복한다.

· 7 min read · PALDYN Team

지난 글에서 선형 회귀가 연속값 예측 문제를 풀었다. 이번에는 분류 문제를 다루는 **로지스틱 회귀(Logistic Regression)**를 살펴본다. 이름에 “회귀”가 붙었지만 분류 알고리즘이다. 선형 회귀의 출력을 시그모이드 함수로 변환해 확률로 만드는 것이 핵심 아이디어다.

왜 선형 회귀로 분류하면 안 될까

선형 회귀로 이진 분류(y=0 또는 1)를 시도하면 두 가지 문제가 생긴다.

  1. 출력 범위 문제: 선형 회귀 출력 ŷ = wx + b는 (-∞, +∞)인데, 확률은 [0, 1]이어야 한다.
  2. 손실 함수 문제: MSE가 분류에서 비볼록(non-convex)해져 여러 지역 최솟값이 생긴다.

로지스틱 회귀는 시그모이드 함수로 이 두 문제를 동시에 해결한다.

시그모이드: 실수를 확률로

시그모이드 함수는 어떤 실수값도 (0, 1) 범위로 압축한다.

σ(z) = 1 / (1 + e⁻ᶻ)
  • z → -∞ : σ → 0
  • z = 0 : σ = 0.5
  • z → +∞ : σ → 1
import numpy as np
import torch
import torch.nn as nn

# 시그모이드 직접 구현
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

z_values = np.array([-6, -3, -1, 0, 1, 3, 6])
probs    = sigmoid(z_values)
for z, p in zip(z_values, probs):
    bar = "█" * int(p * 20)
    print(f"z={z:3d}: σ={p:.4f}  {bar}")
# z=-6: σ=0.0025  
# z= 0: σ=0.5000  ██████████
# z=+6: σ=0.9975  ████████████████████

# PyTorch: nn.Sigmoid() 또는 torch.sigmoid()
z_t = torch.tensor([-6.0, 0.0, 6.0])
print(torch.sigmoid(z_t))  # tensor([0.0025, 0.5000, 0.9975])

로지스틱 회귀 모델

z = w₁x₁ + w₂x₂ + ... + wₙxₙ + b   (선형 결합)
ŷ = σ(z) = P(y=1|x)                  (확률 출력)

결정 경계: ŷ ≥ 0.5 → class 1, ŷ < 0.5 → class 0. 이는 z ≥ 0이 class 1과 동치다.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report

# 유방암 데이터 (이진 분류)
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 스케일링 필수 (특성 범위 차이 큼)
scaler  = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test  = scaler.transform(X_test)

# 로지스틱 회귀 학습
clf = LogisticRegression(C=1.0, max_iter=1000, random_state=42)
clf.fit(X_train, y_train)

# 평가
y_pred  = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)[:, 1]  # P(y=1) 확률
print(classification_report(y_test, y_pred))

# 결정 경계 임계값 조정 (기본 0.5)
threshold = 0.3  # 재현율 중시 → 임계값 낮춤
y_pred_adj = (y_proba >= threshold).astype(int)
print(classification_report(y_test, y_pred_adj))

손실 함수: Binary Cross-Entropy

로지스틱 회귀의 손실 함수는 MSE가 아닌 **BCE(Binary Cross-Entropy)**다.

L = -[y·log(ŷ) + (1-y)·log(1-ŷ)]
  • y=1, ŷ→1: 손실 → 0 (정확한 예측)
  • y=1, ŷ→0: 손실 → ∞ (완전히 틀린 예측)
  • BCE를 최소화 = MLE (최대 우도 추정) 수행
import torch
import torch.nn as nn
import torch.optim as optim

# PyTorch로 처음부터 구현
class LogisticRegressionPyTorch(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, 1)  # wx + b
    
    def forward(self, x):
        return self.linear(x)  # logit 반환 (sigmoid 없음)

model = LogisticRegressionPyTorch(input_dim=X_train.shape[1])

# BCEWithLogitsLoss = sigmoid + BCE (수치적으로 더 안정)
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)

X_t = torch.FloatTensor(X_train)
y_t = torch.FloatTensor(y_train).unsqueeze(1)

for epoch in range(200):
    model.train()
    optimizer.zero_grad()
    logits = model(X_t)
    loss   = criterion(logits, y_t)
    loss.backward()
    optimizer.step()

# 추론: sigmoid로 확률 변환
model.eval()
with torch.no_grad():
    logits  = model(torch.FloatTensor(X_test))
    probs   = torch.sigmoid(logits).squeeze().numpy()
    preds   = (probs >= 0.5).astype(int)

로지스틱 회귀: 시그모이드와 결정 경계

다중 분류: Softmax

클래스가 3개 이상이면 **소프트맥스(Softmax)**를 사용한다.

# Softmax: P(class=k) = e^zₖ / Σⱼ e^zⱼ
# 모든 클래스 확률의 합 = 1

from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# multi_class='auto' → 3클래스에서 softmax 자동 사용
clf_mc = LogisticRegression(multi_class='auto', solver='lbfgs', max_iter=500)
clf_mc.fit(X_train, y_train)

# 각 클래스의 확률
proba = clf_mc.predict_proba(X_test[:5])
print("클래스별 확률 (행 합=1):")
for row in proba:
    print([f"{p:.3f}" for p in row])

# PyTorch: CrossEntropyLoss = Softmax + Log + NLL
criterion = nn.CrossEntropyLoss()  # 내부에 Softmax 포함
# 마지막 레이어는 Softmax 없이 logit 출력
model_mc = nn.Linear(4, 3)  # 3 클래스
logits   = model_mc(torch.FloatTensor(X_train))
loss     = criterion(logits, torch.LongTensor(y_train))

규제화와 클래스 불균형

# C 파라미터: 정규화 역강도 (C=1/λ)
# C 작을수록 강한 규제 → 더 단순한 모델
for C in [0.01, 0.1, 1.0, 10.0]:
    clf = LogisticRegression(C=C, max_iter=500)
    clf.fit(X_train, y_train)
    acc = clf.score(X_test, y_test)
    print(f"C={C:.2f}: 검증 정확도 = {acc:.4f}")

# 클래스 불균형 대응
clf_balanced = LogisticRegression(
    class_weight='balanced',   # 소수 클래스에 자동 가중치
    C=1.0, max_iter=500
)
clf_balanced.fit(X_train, y_train)
# 또는 수동: class_weight={0: 1, 1: 10}

로지스틱 회귀 구현 및 다중 분류

로지스틱 회귀의 장점과 한계

장점:

  • 확률 출력 → 해석 용이, 불확실성 정량화
  • 학습 빠름, 특성 중요도 파악 가능 (계수 크기)
  • 작은 데이터에서 과적합 적음
  • 딥러닝의 출력 레이어로 그대로 사용

한계:

  • 결정 경계가 선형 → 비선형 문제에 약함
  • 특성 간 상호작용 자동 학습 불가
  • 이미지, 텍스트 같은 고차원 비정형 데이터에 직접 적용 어려움

로지스틱 회귀는 딥러닝의 마지막 레이어(분류 헤드)와 수학적으로 동일하다. 따라서 이 알고리즘을 이해하면 신경망의 출력 레이어도 자연스럽게 이해된다.

지난 글: 선형 회귀: 예측 모델의 출발점

다음 글: K-최근접 이웃(KNN): 가장 직관적인 분류 알고리즘


읽어주셔서 감사합니다. 😊