선형 회귀 완벽 이해 - 데이터로 미래 예측하기

데이터 과학의 기초이자 가장 강력한 도구인 선형 회귀를 초급자도 이해할 수 있도록 쉽게 설명합니다. 일상 생활의 예시와 실무 코드를 통해 예측 모델을 직접 만들어보세요.

---

목차

1. 선형_회귀란_무엇인가
2. 경사하강법
3. 손실_함수_MSE
4. 다중_선형_회귀
5. 과적합과_정규화
6. 특성_스케일링
7. 모델_평가_지표
8. 실전_예제_주택_가격_예측

---

1. 선형_회귀란_무엇인가

시작하며

여러분이 부동산 앱을 만든다고 상상해보세요. 사용자가 "30평대 아파트의 예상 가격이 얼마일까요?"라고 물어봤을 때, 어떻게 답을 줄 수 있을까요?

과거 데이터를 보니 20평은 3억, 40평은 6억이었습니다. 그렇다면 30평은?

직관적으로 4억 5천 정도라고 추측할 수 있겠죠. 이것이 바로 선형 회귀의 기본 아이디어입니다.

선형 회귀는 마치 점들 사이에 가장 잘 맞는 직선을 그리는 것과 같습니다. 이 직선을 이용하면 아직 보지 못한 값도 예측할 수 있습니다.

실제로 이 기술은 주식 예측, 매출 예상, 고객 이탈률 계산 등 수많은 실무 상황에서 사용됩니다. 데이터 과학의 가장 기초이자 가장 강력한 도구입니다.

개요

간단히 말해서, 선형 회귀는 데이터의 패턴을 찾아서 직선 방정식으로 표현하는 것입니다. 수학 시간에 배웠던 y = ax + b 공식 기억나시나요?

바로 그것입니다. 여기서 x는 우리가 알고 있는 값(평수), y는 예측하고 싶은 값(가격), a는 기울기, b는 y절편입니다.

선형 회귀는 수많은 실제 데이터를 보고 가장 적합한 a와 b 값을 자동으로 찾아줍니다. 기존에는 엑셀에서 수동으로 그래프를 그리고 눈으로 대충 직선을 그어야 했다면, 이제는 파이썬 코드 몇 줄로 컴퓨터가 수학적으로 가장 완벽한 직선을 찾아줍니다.

선형 회귀의 핵심 특징은 세 가지입니다. 첫째, 해석하기 쉽습니다(기울기가 클수록 영향이 크다는 의미).

둘째, 빠릅니다(복잡한 AI 모델보다 훨씬 빠름). 셋째, 다른 복잡한 모델의 기초가 됩니다.

이러한 특징들 덕분에 실무에서 첫 번째로 시도해보는 모델이 되는 것입니다.

코드 예제

import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# 데이터 준비: 평수와 가격(억 원)
평수 = np.array([20, 25, 30, 35, 40]).reshape(-1, 1)  # 2차원 배열로 변환
가격 = np.array([3.0, 3.8, 4.5, 5.2, 6.0])

# 모델 생성 및 학습
model = LinearRegression()
model.fit(평수, 가격)  # 데이터로부터 패턴 학습

# 예측: 28평 아파트 가격은?
새로운_평수 = np.array([[28]])
예측_가격 = model.predict(새로운_평수)
print(f"28평 아파트 예상 가격: {예측_가격[0]:.2f}억 원")

설명

이것이 하는 일: 위 코드는 아파트 평수와 가격 데이터를 보고, 새로운 평수의 가격을 예측하는 모델을 만듭니다. 첫 번째로, 데이터를 준비합니다.

평수는 입력 변수(x), 가격은 출력 변수(y)가 됩니다. reshape(-1, 1)은 scikit-learn 라이브러리가 요구하는 2차원 배열 형태로 변환하는 과정입니다.

마치 엑셀 표처럼 행과 열이 있는 형태로 만드는 것이죠. 그 다음으로, LinearRegression 모델을 생성하고 fit() 메서드로 학습시킵니다.

이 순간 컴퓨터는 주어진 5개의 데이터 포인트를 보고 "어떤 직선이 이 점들을 가장 잘 표현할까?"를 계산합니다. 내부적으로는 복잡한 수학 계산이 일어나지만, 우리는 단 한 줄의 코드만 작성하면 됩니다.

마지막으로, predict() 메서드로 새로운 값을 예측합니다. 28평이라는 값을 넣으면, 학습된 직선 방정식에 대입하여 약 4.26억 원이라는 예측값을 내놓습니다.

이것은 기존 데이터의 패턴을 따라 계산된 과학적인 예측입니다. 여러분이 이 코드를 사용하면 단 몇 초 만에 수백, 수천 개의 예측을 만들어낼 수 있습니다.

실무에서는 고객 이탈 예측, 광고 효과 분석, 재고 수요 예측 등 다양한 비즈니스 문제를 해결하는 데 활용됩니다. 무엇보다 결과를 상사나 고객에게 설명하기 쉽다는 장점이 있습니다.

실전 팁

💡 항상 데이터를 시각화해보세요. plt.scatter()로 점들을 그리고 plt.plot()으로 예측 직선을 그려보면, 모델이 얼마나 잘 맞는지 한눈에 볼 수 있습니다.

💡 선형 회귀는 직선만 그릴 수 있습니다. 만약 데이터가 곡선 형태라면(예: S자 곡선) 다항 회귀나 다른 모델을 사용해야 합니다.

💡 이상치(outlier)에 매우 민감합니다. 한 개의 극단적인 값이 전체 직선을 왜곡시킬 수 있으니, 데이터 전처리에서 이상치를 꼭 확인하세요.

💡 model.coef_와 model.intercept_를 출력하면 학습된 기울기(a)와 절편(b)을 볼 수 있습니다. 이를 통해 "평수가 1평 증가하면 가격이 얼마나 오르는지" 구체적으로 해석할 수 있습니다.

💡 실무에서는 단일 변수보다 다중 변수(평수, 층수, 역까지 거리 등)를 사용하는 경우가 많습니다. 다음 카드에서 배울 다중 선형 회귀로 자연스럽게 확장할 수 있습니다.

---

2. 경사하강법

시작하며

여러분이 안개 낀 산에서 길을 잃었다고 상상해보세요. 가장 낮은 곳(마을)으로 내려가야 하는데, 앞이 보이지 않습니다.

어떻게 할까요? 가장 현명한 방법은 발밑의 경사를 느껴보고, 가장 가파르게 내려가는 방향으로 한 걸음씩 이동하는 것입니다.

이것을 계속 반복하면 결국 골짜기에 도착하겠죠. 바로 이것이 경사하강법(Gradient Descent)의 원리입니다.

컴퓨터가 최적의 모델을 찾는 방법이죠. 선형 회귀에서 "최적"이란 예측값과 실제값의 차이(오차)가 가장 작은 상태를 의미합니다.

경사하강법은 이 오차를 조금씩 줄여나가는 똑똑한 알고리즘입니다.

개요

간단히 말해서, 경사하강법은 잘못된 예측을 조금씩 수정해가며 최적의 모델을 찾아가는 반복 알고리즘입니다. 처음에는 기울기(a)와 절편(b)을 아무 값이나 설정합니다(예: a=0, b=0).

당연히 예측이 엉망이겠죠. 그러면 "a를 조금 늘리면 오차가 줄어들까?

늘어날까?"를 계산합니다. 만약 줄어든다면 그쪽으로 조금 이동합니다.

이것을 수천 번 반복하면 오차가 최소인 지점에 도달합니다. 기존에는 정규방정식(Normal Equation)이라는 수학 공식으로 한 번에 답을 구했지만, 데이터가 수백만 개가 되면 계산이 너무 오래 걸립니다.

경사하강법은 조금씩 접근하기 때문에 대용량 데이터에서도 빠르게 작동합니다. 이 알고리즘의 핵심은 세 가지입니다.

학습률(learning rate): 한 번에 얼마나 이동할지 결정. 너무 크면 최적점을 지나치고, 너무 작으면 도착이 느립니다.

반복 횟수: 보통 수천~수만 번 반복합니다. 수렴 조건: 오차가 더 이상 줄어들지 않으면 멈춥니다.

이 세 가지 균형이 모델 학습의 성패를 가릅니다.

코드 예제

import numpy as np

# 간단한 경사하강법 구현
def gradient_descent(X, y, learning_rate=0.01, iterations=1000):
    m = len(y)  # 데이터 개수
    a = 0  # 기울기 초기값
    b = 0  # 절편 초기값

    for i in range(iterations):
        # 예측값 계산
        y_pred = a * X + b

        # 오차 계산
        error = y_pred - y

        # 경사(gradient) 계산
        a_gradient = (2/m) * np.sum(error * X)
        b_gradient = (2/m) * np.sum(error)

        # 파라미터 업데이트 (경사 반대 방향으로 이동)
        a = a - learning_rate * a_gradient
        b = b - learning_rate * b_gradient

        # 100번마다 현재 손실 출력
        if i % 100 == 0:
            loss = np.mean(error ** 2)
            print(f"반복 {i}: 손실 = {loss:.4f}")

    return a, b

# 사용 예시
X = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])
a, b = gradient_descent(X, y)
print(f"최종 모델: y = {a:.2f}x + {b:.2f}")

설명

이것이 하는 일: 위 코드는 직접 경사하강법을 구현하여 데이터에 가장 잘 맞는 직선의 기울기와 절편을 찾아냅니다. 첫 번째로, 초기값을 설정합니다.

a와 b를 0으로 시작하는데, 사실 아무 값이나 상관없습니다. 중요한 것은 이 값들이 어떻게 변해가는지입니다.

iterations(반복 횟수)는 "몇 번 시도해볼까?"를 결정하는 하이퍼파라미터입니다. 그 다음으로, 반복문 안에서 핵심 계산이 일어납니다.

현재의 a와 b로 예측값을 만들고, 실제값과의 차이(error)를 계산합니다. 그리고 "a를 어느 방향으로 얼마나 조정해야 오차가 줄어들까?"를 나타내는 경사(gradient)를 미분 공식으로 구합니다.

2/m은 평균을 구하기 위한 수학적 상수입니다. 마지막으로, 파라미터를 업데이트합니다.

learning_rate를 곱해서 조금씩만 이동하는 것이 포인트입니다. 만약 learning_rate=1로 설정하면 너무 크게 점프해서 최적점을 계속 지나칠 수 있습니다.

반대로 0.0001처럼 너무 작으면 수렴하는데 하루가 걸릴 수도 있습니다. 여러분이 이 코드를 실행하면 손실(loss)이 점점 줄어드는 것을 볼 수 있습니다.

실무에서는 scikit-learn의 SGDRegressor를 사용하면 더 최적화된 경사하강법을 쓸 수 있지만, 원리를 이해하는 것이 중요합니다. 딥러닝에서도 똑같은 원리가 사용되기 때문입니다.

실전 팁

💡 학습률을 0.001, 0.01, 0.1, 1.0으로 바꿔가며 실험해보세요. 손실이 어떻게 변하는지 관찰하면 학습률의 중요성을 직접 느낄 수 있습니다.

💡 실무에서는 Adam, RMSprop 같은 개선된 옵티마이저를 사용합니다. 이들은 자동으로 학습률을 조정해주어 수동 튜닝의 고통을 줄여줍니다.

💡 손실이 튀거나 NaN이 나온다면 학습률이 너무 큰 것입니다. 10배씩 줄여보세요(0.1 → 0.01 → 0.001).

💡 조기 종료(Early Stopping) 기법을 사용하세요. 손실이 연속 10회 개선되지 않으면 학습을 멈추면, 불필요한 계산을 줄일 수 있습니다.

💡 미니배치 경사하강법(Mini-batch GD)을 사용하면 전체 데이터가 아닌 일부만 사용해서 더 빠르게 학습할 수 있습니다. 데이터가 100만 개 이상일 때 필수입니다.

---

3. 손실_함수_MSE

시작하며

여러분이 양궁 선수라고 상상해보세요. 10발을 쏘고 나서 실력을 평가하려면 어떻게 해야 할까요?

과녁 중심에서 얼마나 떨어졌는지를 측정하면 되겠죠. 1cm 빗나간 것, 5cm 빗나간 것, 15cm 빗나간 것을 모두 더해서 평균을 내면 "평균적으로 얼마나 정확한가"를 알 수 있습니다.

바로 이것이 손실 함수의 개념입니다. 모델의 예측이 실제값에서 얼마나 벗어났는지를 숫자로 표현하는 것이죠.

선형 회귀에서 가장 많이 사용하는 손실 함수가 MSE(Mean Squared Error, 평균 제곱 오차)입니다. 이름은 어렵지만 개념은 간단합니다.

개요

간단히 말해서, MSE는 예측값과 실제값의 차이를 제곱해서 평균 낸 값입니다. 왜 단순히 차이를 평균 내지 않고 제곱할까요?

두 가지 이유가 있습니다. 첫째, 양수 오차(+3)와 음수 오차(-3)가 서로 상쇄되는 것을 막습니다.

둘째, 큰 오차에 더 큰 페널티를 줍니다. 1cm 빗나간 것은 1², 10cm 빗나간 것은 10²=100이 되어 큰 실수를 더 강하게 처벌합니다.

기존에는 MAE(절댓값 오차)를 쓰기도 했지만, MSE가 미분하기 쉬워서 경사하강법과 궁합이 좋습니다. 수학적으로 최적화하기 편한 것이죠.

MSE의 핵심 특징: 0에 가까울수록 완벽한 모델입니다. 0은 모든 예측이 정확하다는 의미입니다.

단위가 제곱되어 있습니다(원래 단위가 억 원이면 MSE는 억²). 따라서 루트를 씌운 RMSE를 더 많이 봅니다.

이상치에 민감합니다. 한 개의 극단적인 오차가 전체 MSE를 크게 높입니다.

코드 예제

import numpy as np
from sklearn.metrics import mean_squared_error, mean_absolute_error

# 실제 가격
actual = np.array([3.0, 4.5, 6.0, 5.5, 7.0])

# 모델의 예측 가격
predicted = np.array([3.2, 4.3, 6.5, 5.8, 6.8])

# MSE 계산 (수동)
mse_manual = np.mean((actual - predicted) ** 2)
print(f"MSE (수동 계산): {mse_manual:.4f}")

# MSE 계산 (scikit-learn)
mse = mean_squared_error(actual, predicted)
print(f"MSE (sklearn): {mse:.4f}")

# RMSE 계산 (원래 단위로 되돌리기)
rmse = np.sqrt(mse)
print(f"RMSE: {rmse:.4f}억 원")

# MAE 계산 (비교용)
mae = mean_absolute_error(actual, predicted)
print(f"MAE: {mae:.4f}억 원")

# 해석: 평균적으로 약 0.24억 원(2400만 원) 오차

설명

이것이 하는 일: 위 코드는 모델의 예측값과 실제값을 비교하여 평균적으로 얼마나 틀렸는지를 다양한 방법으로 계산합니다. 첫 번째로, 수동으로 MSE를 계산합니다.

(actual - predicted)는 각 예측의 오차를 계산하고, ** 2는 제곱, np.mean()은 평균을 구합니다. 단 한 줄로 MSE의 정의를 그대로 코드로 옮긴 것입니다.

이것을 이해하면 MSE가 무엇인지 완벽히 아는 것입니다. 그 다음으로, scikit-learn의 mean_squared_error() 함수를 사용합니다.

결과는 동일하지만, 실무에서는 이 함수를 씁니다. 왜냐하면 다양한 옵션(가중치, 다중 출력 등)을 지원하고, 다른 평가 지표들과 일관된 인터페이스를 제공하기 때문입니다.

마지막으로, RMSE와 MAE를 함께 계산합니다. RMSE는 np.sqrt(mse)로 간단히 구할 수 있고, 이것은 "평균적으로 약 0.24억 원(2400만 원) 정도 예측이 빗나간다"는 의미로 해석됩니다.

MAE는 제곱하지 않고 절댓값만 사용하므로, 큰 오차의 영향을 덜 받습니다. 여러분이 이 코드를 프로젝트에 적용하면 모델의 성능을 객관적으로 측정할 수 있습니다.

실무에서는 "이번 달 모델의 RMSE가 지난달보다 10% 개선되었습니다"처럼 보고합니다. 이상치가 많은 데이터라면 MAE를 함께 보고하여 robust한 평가를 할 수 있습니다.

실전 팁

💡 RMSE와 MAE를 함께 보세요. RMSE가 MAE보다 훨씬 크다면 이상치가 많다는 신호입니다.

💡 MSE 값 자체는 의미 없습니다(단위가 제곱이라). 항상 RMSE로 변환해서 "평균 예측 오차가 X원"이라고 해석하세요.

💡 모델 비교 시에는 같은 테스트 데이터로 계산한 MSE를 비교합니다. 학습 데이터의 MSE는 의미가 없습니다(과적합 가능).

💡 비즈니스 목표와 연결하세요. "고객이 허용 가능한 오차 범위"가 있다면, RMSE가 그 이하여야 실전 투입이 가능합니다.

💡 R² 점수와 함께 사용하세요. MSE는 절댓값이라 모델 간 비교가 어렵지만, R²는 0~1 사이 값이라 직관적입니다(뒤에서 설명).

---

4. 다중_선형_회귀

시작하며

여러분이 중고차 가격을 예측한다고 상상해보세요. 주행거리만 보고 가격을 예측하면 정확할까요?

아니죠. 연식, 사고 이력, 브랜드, 옵션 등 수많은 요소가 가격에 영향을 줍니다.

현실 세계의 문제는 대부분 여러 변수가 복합적으로 작용합니다. 바로 이럴 때 필요한 것이 다중 선형 회귀(Multiple Linear Regression)입니다.

여러 개의 x 변수를 동시에 고려하는 것이죠. 수식으로 표현하면 y = a₁x₁ + a₂x₂ + a₃x₃ + b입니다.

x₁은 주행거리, x₂는 연식, x₃는 브랜드 점수처럼 여러 요소를 한꺼번에 넣는 것입니다.

개요

간단히 말해서, 다중 선형 회귀는 여러 개의 입력 변수를 사용하여 출력 값을 예측하는 모델입니다. 현실의 데이터는 하나의 변수만으로 설명되지 않습니다.

아파트 가격은 평수뿐 아니라 층수, 역세권 여부, 학군, 건물 나이 등 수십 개 요소에 영향을 받습니다. 다중 선형 회귀는 이 모든 것을 동시에 고려합니다.

예를 들어, "역세권이면서 고층이면서 넓은 아파트"의 가격을 정확하게 예측할 수 있습니다. 기존의 단순 선형 회귀는 2차원 그래프(x, y)였다면, 다중 선형 회귀는 3차원 이상의 공간에서 평면이나 초평면을 그리는 것입니다.

시각화하기는 어렵지만, 수학적 원리는 똑같습니다. 핵심 특징: 각 변수마다 개별적인 기울기(계수)를 가집니다.

변수 간 상관관계를 고려합니다(다중공선성 문제 주의). 변수가 많을수록 복잡하지만, 과적합 위험도 커집니다.

이 균형을 맞추는 것이 데이터 과학자의 역량입니다.

코드 예제

import numpy as np
from sklearn.linear_model import LinearRegression
import pandas as pd

# 다차원 데이터 준비 (평수, 층수, 역까지 거리(km))
X = np.array([
    [30, 5, 0.5],   # 30평, 5층, 역까지 500m
    [25, 2, 1.2],
    [35, 10, 0.3],
    [40, 15, 0.8],
    [20, 3, 2.0]
])
y = np.array([4.5, 3.8, 5.5, 6.2, 3.0])  # 가격(억 원)

# 모델 학습
model = LinearRegression()
model.fit(X, y)

# 각 변수의 영향력 확인
feature_names = ['평수', '층수', '역까지_거리']
for name, coef in zip(feature_names, model.coef_):
    print(f"{name}의 계수: {coef:.4f}")
print(f"절편: {model.intercept_:.4f}")

# 새로운 아파트 예측 (32평, 7층, 역까지 600m)
new_apt = np.array([[32, 7, 0.6]])
predicted_price = model.predict(new_apt)
print(f"\n예측 가격: {predicted_price[0]:.2f}억 원")

설명

이것이 하는 일: 위 코드는 아파트의 평수, 층수, 역까지 거리를 모두 고려하여 가격을 예측하는 다차원 모델을 만듭니다. 첫 번째로, 데이터를 2차원 배열로 준비합니다.

각 행은 하나의 샘플(아파트), 각 열은 하나의 특성(평수, 층수, 거리)을 나타냅니다. 단순 선형 회귀와 달리 X의 shape가 (5, 3)이 됩니다.

5개의 샘플, 3개의 특성이라는 의미입니다. 그 다음으로, fit()으로 학습시킵니다.

내부적으로는 3차원 공간에서 최적의 평면을 찾는 과정이지만, 코드는 동일합니다. 이것이 scikit-learn의 멋진 점입니다.

변수가 3개든 300개든 같은 코드를 씁니다. 마지막으로, 학습된 계수를 확인합니다.

model.coef_는 배열 형태로 각 변수의 기울기를 반환합니다. 예를 들어 평수 계수가 0.15라면 "다른 조건이 같을 때 평수 1평 증가 시 1500만 원 상승"을 의미합니다.

역까지 거리 계수가 음수라면 역에 가까울수록 비싸다는 뜻입니다. 여러분이 이 코드를 실무에 적용하면 훨씬 현실적인 예측을 할 수 있습니다.

마케팅 분야에서는 광고비, 시즌, 날씨를 입력으로 매출을 예측하거나, HR에서는 경력, 학력, 면접 점수로 연봉을 예측하는 등 다양하게 활용됩니다. 변수가 많아질수록 정확도가 높아지지만, 해석은 어려워진다는 트레이드오프가 있습니다.

실전 팁

💡 변수 간 스케일을 맞추세요. 평수(2040)와 층수(120)는 괜찮지만, 거리(0~2)와 가격(억 단위)는 스케일 차이가 커서 StandardScaler를 사용해야 합니다(다음 카드 참고).

💡 너무 많은 변수를 넣지 마세요. 변수가 샘플 수의 10% 이상이면 과적합 위험이 큽니다. 50개 샘플이면 변수는 5개 이하가 적당합니다.

💡 다중공선성을 체크하세요. 두 변수가 높은 상관관계(예: 평수와 방 개수)를 가지면 계수 해석이 왜곡됩니다. VIF(Variance Inflation Factor) 지표로 확인할 수 있습니다.

💡 계수의 부호와 크기를 해석하여 비즈니스 인사이트를 얻으세요. "역까지 거리가 가장 큰 영향을 준다"는 발견은 부동산 전략에 중요한 정보입니다.

💡 범주형 변수(예: 브랜드)는 원-핫 인코딩으로 변환한 후 사용합니다. pd.get_dummies() 함수가 유용합니다.

---

5. 과적합과_정규화

시작하며

여러분이 시험 공부를 한다고 상상해보세요. 기출문제 10개를 달달 외워서 100점을 맞았습니다.

훌륭할까요? 아니죠.

진짜 시험에서는 비슷하지만 다른 문제가 나올 테니까요. 기출문제만 외운 사람은 실전에서 망합니다.

이것이 바로 과적합(Overfitting)입니다. 머신러닝에서도 똑같습니다.

학습 데이터는 완벽하게 맞추지만, 새로운 데이터에서는 엉망인 모델이 과적합된 것입니다. 정규화(Regularization)는 이것을 막는 기술입니다.

모델이 너무 복잡해지는 것을 의도적으로 제한하여, 일반화 능력을 높이는 것이죠.

개요

간단히 말해서, 과적합은 모델이 학습 데이터에만 과도하게 최적화되어 새 데이터에서는 성능이 떨어지는 현상입니다. 왜 과적합이 발생할까요?

변수가 너무 많거나, 데이터가 너무 적거나, 모델이 너무 복잡할 때 발생합니다. 예를 들어 5개의 데이터로 10개의 변수를 사용하면, 모델은 데이터의 노이즈까지 학습해버립니다.

이것은 진짜 패턴이 아니라 우연의 일치를 배운 것입니다. 정규화는 계수(기울기)가 너무 커지는 것을 페널티로 제한합니다.

Ridge 정규화(L2)는 계수의 제곱을 페널티로, Lasso 정규화(L1)는 계수의 절댓값을 페널티로 줍니다. Lasso는 불필요한 변수의 계수를 아예 0으로 만들어 자동으로 변수 선택까지 해줍니다.

핵심 개념: 편향-분산 트레이드오프. 정규화를 강하게 하면 과적합은 줄지만 학습 데이터조차 덜 맞춥니다(편향 증가).

정규화를 약하게 하면 과적합 위험이 커집니다(분산 증가). 최적의 균형점을 찾는 것이 목표입니다.

코드 예제

from sklearn.linear_model import Ridge, Lasso, LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import numpy as np

# 데이터 준비 (변수가 많은 케이스)
np.random.seed(42)
X = np.random.rand(50, 20)  # 50개 샘플, 20개 변수
y = X[:, 0] * 2 + X[:, 1] * 3 + np.random.randn(50) * 0.5  # 실제로는 2개만 의미있음

# 학습/테스트 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# 일반 선형 회귀 (과적합 위험)
lr = LinearRegression().fit(X_train, y_train)
print(f"일반 회귀 - 학습 MSE: {mean_squared_error(y_train, lr.predict(X_train)):.4f}")
print(f"일반 회귀 - 테스트 MSE: {mean_squared_error(y_test, lr.predict(X_test)):.4f}")

# Ridge 정규화 (L2)
ridge = Ridge(alpha=1.0).fit(X_train, y_train)
print(f"\nRidge - 학습 MSE: {mean_squared_error(y_train, ridge.predict(X_train)):.4f}")
print(f"Ridge - 테스트 MSE: {mean_squared_error(y_test, ridge.predict(X_test)):.4f}")

# Lasso 정규화 (L1, 변수 선택)
lasso = Lasso(alpha=0.1).fit(X_train, y_train)
print(f"\nLasso - 학습 MSE: {mean_squared_error(y_train, lasso.predict(X_train)):.4f}")
print(f"Lasso - 테스트 MSE: {mean_squared_error(y_test, lasso.predict(X_test)):.4f}")
print(f"Lasso가 선택한 변수 개수: {np.sum(lasso.coef_ != 0)}")

설명

이것이 하는 일: 위 코드는 과적합이 발생하기 쉬운 상황(변수 많음, 데이터 적음)에서 일반 회귀와 정규화 회귀의 성능을 비교합니다. 첫 번째로, 인위적인 데이터를 생성합니다.

20개 변수 중 실제로 의미 있는 것은 처음 2개뿐입니다. 나머지 18개는 노이즈입니다.

과적합된 모델은 이 노이즈까지 학습하려고 할 것입니다. train_test_split으로 데이터를 나누는 것이 매우 중요합니다.

같은 데이터로 학습하고 평가하면 과적합을 절대 발견할 수 없습니다. 그 다음으로, 세 가지 모델을 학습시킵니다.

일반 선형 회귀는 학습 MSE는 낮지만 테스트 MSE가 높게 나올 가능성이 큽니다(과적합). Ridge는 alpha(정규화 강도) 값으로 패널티를 조절합니다.

alpha가 클수록 계수가 작아지고 단순한 모델이 됩니다. Lasso는 더 aggressive해서 계수를 아예 0으로 만듭니다.

마지막으로, 테스트 MSE를 비교합니다. 정규화 모델의 테스트 MSE가 더 낮다면, 정규화가 성공적으로 과적합을 방지한 것입니다.

Lasso의 계수를 보면 0이 아닌 계수가 몇 개 안 됩니다. 즉, 20개 중 중요한 몇 개만 자동으로 선택한 것이죠.

여러분이 실무에서 변수가 수십 개 이상일 때는 항상 정규화를 고려해야 합니다. 특히 유전자 데이터(수만 개 변수), 텍스트 데이터(수천 개 단어), 센서 데이터(수백 개 시계열) 같은 고차원 데이터에서 필수입니다.

alpha 값은 교차 검증으로 최적값을 찾습니다.

실전 팁

💡 학습 MSE와 테스트 MSE의 갭이 크면 과적합입니다. 정규화 강도를 높이거나 변수를 줄이세요.

💡 alpha 값은 GridSearchCV로 자동 탐색할 수 있습니다. [0.001, 0.01, 0.1, 1, 10, 100]처럼 넓은 범위를 시도해보세요.

💡 Lasso로 변수를 선택한 후, 선택된 변수만으로 일반 회귀를 다시 학습하는 2단계 전략도 효과적입니다.

💡 ElasticNet은 Ridge와 Lasso를 혼합한 것으로, 두 장점을 모두 가집니다. 실무에서 자주 사용됩니다.

💡 데이터가 충분하다면(수천 개 이상) 정규화 없이도 잘 작동합니다. 정규화는 데이터가 부족할 때의 보험입니다.

---

6. 특성_스케일링

시작하며

여러분이 농구 선수와 마라톤 선수의 체력을 비교한다고 상상해보세요. 키는 cm 단위(180200), 몸무게는 kg 단위(70100)로 측정합니다.

키 차이 20cm와 몸무게 차이 30kg 중 어느 것이 더 중요할까요? 단위가 다르기 때문에 직접 비교가 불가능합니다.

머신러닝 모델도 마찬가지입니다. 평수(2040)와 가격(3억10억)을 같이 사용하면, 숫자가 큰 가격이 부당하게 더 큰 영향을 줍니다.

특성 스케일링(Feature Scaling)은 이런 불공정을 해결합니다. 모든 변수를 비슷한 범위로 맞춰서 공정한 경쟁을 시키는 것이죠.

개요

간단히 말해서, 특성 스케일링은 서로 다른 범위를 가진 변수들을 같은 척도로 변환하는 전처리 기법입니다. 가장 많이 사용하는 두 가지 방법이 있습니다.

표준화(Standardization): 평균을 0, 표준편차를 1로 만듭니다. 공식은 (x - 평균) / 표준편차입니다.

정규 분포를 따르는 데이터에 적합합니다. 정규화(Normalization): 최소값을 0, 최대값을 1로 만듭니다.

공식은 (x - 최소) / (최대 - 최소)입니다. 범위가 제한된 변수에 적합합니다.

왜 필요할까요? 경사하강법이 빠르게 수렴합니다.

스케일이 다르면 특정 방향으로만 경사가 급해져서 지그재그로 느리게 수렴합니다. 정규화 모델(Ridge, Lasso)이 제대로 작동합니다.

계수 크기로 페널티를 주는데, 변수마다 스케일이 다르면 불공정합니다. 모델 해석이 쉬워집니다.

계수의 절댓값으로 변수 중요도를 비교할 수 있습니다. 핵심 원칙: 학습 데이터로 스케일러를 fit하고, 같은 스케일러로 테스트 데이터를 transform합니다.

테스트 데이터로 fit하면 데이터 누수(leakage)가 발생합니다.

코드 예제

from sklearn.preprocessing import StandardScaler, MinMaxScaler
import numpy as np
import pandas as pd

# 스케일이 다른 데이터
data = np.array([
    [30, 5, 500],      # 평수, 층수, 역까지 거리(m)
    [25, 2, 1200],
    [35, 10, 300],
    [40, 15, 800]
])

print("원본 데이터:")
print(pd.DataFrame(data, columns=['평수', '층수', '거리(m)']))

# 표준화 (평균 0, 표준편차 1)
scaler_std = StandardScaler()
scaled_std = scaler_std.fit_transform(data)
print("\n표준화 후:")
print(pd.DataFrame(scaled_std, columns=['평수', '층수', '거리(m)']))
print(f"평균: {scaled_std.mean(axis=0)}")
print(f"표준편차: {scaled_std.std(axis=0)}")

# 정규화 (0~1 범위)
scaler_minmax = MinMaxScaler()
scaled_minmax = scaler_minmax.fit_transform(data)
print("\n정규화 후:")
print(pd.DataFrame(scaled_minmax, columns=['평수', '층수', '거리(m)']))
print(f"최소값: {scaled_minmax.min(axis=0)}")
print(f"최대값: {scaled_minmax.max(axis=0)}")

# 새로운 데이터에 적용 (fit 없이 transform만)
new_data = np.array([[32, 7, 600]])
new_scaled = scaler_std.transform(new_data)
print(f"\n새 데이터 표준화: {new_scaled}")

설명

이것이 하는 일: 위 코드는 평수, 층수, 거리처럼 스케일이 다른 변수들을 표준화와 정규화 두 가지 방법으로 변환합니다. 첫 번째로, 원본 데이터를 관찰합니다.

평수는 2040 범위, 층수는 215 범위, 거리는 300~1200 범위로 모두 다릅니다. 이 상태로 모델에 넣으면 거리가 숫자가 크기 때문에 부당하게 큰 영향을 줄 수 있습니다.

데이터를 pandas DataFrame으로 보여주면 더 보기 좋습니다. 그 다음으로, StandardScaler로 표준화합니다.

fit_transform()은 데이터의 평균과 표준편차를 계산(fit)한 후, 그것으로 변환(transform)합니다. 결과를 보면 모든 열의 평균이 0에 가깝고(부동소수점 오차로 정확히 0은 아닐 수 있음), 표준편차가 1입니다.

음수 값이 나올 수 있으며, 이것은 평균보다 작다는 의미입니다. 마지막으로, MinMaxScaler로 정규화합니다.

각 열의 최소값이 0, 최대값이 1이 됩니다. 이 방법은 데이터가 정규 분포를 따르지 않거나, 명확한 최소/최대 범위가 있을 때 적합합니다.

새로운 데이터는 반드시 transform()만 사용해야 합니다. fit()을 다시 하면 완전히 다른 스케일이 적용되어 의미가 없어집니다.

여러분이 실무에서 선형 회귀를 사용할 때는 거의 항상 스케일링을 먼저 해야 합니다. 특히 정규화(Ridge, Lasso), SVM, 신경망에서는 필수입니다.

단, 트리 기반 모델(RandomForest, XGBoost)은 스케일링이 불필요합니다. 파이프라인(Pipeline)을 사용하면 스케일링과 모델 학습을 하나의 단계로 묶을 수 있어 편리합니다.

실전 팁

💡 실무에서는 StandardScaler가 기본입니다. 대부분의 경우 잘 작동합니다. MinMaxScaler는 이상치에 민감하므로 조심하세요.

💡 RobustScaler는 중앙값과 IQR을 사용하여 이상치에 강합니다. 금융 데이터처럼 극단값이 많을 때 유용합니다.

💡 스케일링은 X(입력)에만 적용하고, y(출력)에는 보통 적용하지 않습니다. 단, 신경망에서는 y도 스케일링하는 경우가 있습니다.

💡 범주형 변수(원-핫 인코딩된 0/1 값)는 스케일링하지 마세요. 이미 0~1 범위이고, 의미가 달라집니다.

💡 train-test split 전에 스케일링하면 안 됩니다! 반드시 분리 후, 학습 데이터로 fit하고, 테스트 데이터는 transform만 하세요.

---

7. 모델_평가_지표

시작하며

여러분이 두 개의 날씨 예측 앱을 비교한다고 상상해보세요. 하나는 "내일 비 올 확률 80%"라고 하고, 다른 하나는 "내일 맑음"이라고 합니다.

어느 쪽이 더 정확할까요? 실제 날씨 데이터와 비교해봐야 알 수 있겠죠.

그리고 "얼마나 정확한가"를 숫자로 표현할 수 있다면 더 좋을 것입니다. 머신러닝 모델도 마찬가지입니다.

단순히 "이 모델이 좋다"가 아니라 "R² 점수 0.85로 우수하다"처럼 정량적으로 평가해야 합니다. 선형 회귀에서 가장 많이 사용하는 평가 지표는 R² 점수와 RMSE입니다.

이 두 가지만 알아도 실무에서 충분합니다.

개요

간단히 말해서, R²(결정계수)는 모델이 데이터의 분산을 얼마나 설명하는지를 0~1 사이의 값으로 나타냅니다. R² = 1은 완벽한 예측(모든 점이 직선 위에 있음)을 의미합니다.

R² = 0은 모델이 평균값만 예측하는 것과 같다는 의미입니다. R² < 0은 모델이 평균값보다도 못하다는 의미입니다(매우 나쁜 모델).

일반적으로 R² > 0.7이면 좋은 모델로 간주됩니다(분야마다 다름). RMSE(Root Mean Squared Error)는 앞에서 배운 MSE에 루트를 씌운 것입니다.

원래 데이터와 같은 단위를 가지므로 해석이 쉽습니다. "평균적으로 2400만 원 오차"처럼 직관적으로 이해할 수 있습니다.

두 지표의 차이: R²는 상대적 성능(모델이 얼마나 좋은가), RMSE는 절대적 오차(평균적으로 얼마나 틀리는가)를 나타냅니다. 둘 다 낮을수록/높을수록 좋은 것이 아니라, 각각의 의미를 이해하고 상황에 맞게 사용해야 합니다.

코드 예제

from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
from sklearn.model_selection import train_test_split
import numpy as np

# 데이터 생성
np.random.seed(42)
X = np.random.rand(100, 1) * 10
y = 2 * X.squeeze() + 3 + np.random.randn(100) * 2

# 학습/테스트 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 모델 학습
model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 다양한 평가 지표 계산
r2 = r2_score(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
mae = mean_absolute_error(y_test, y_pred)

print(f"R² 점수: {r2:.4f}")
print(f"RMSE: {rmse:.4f}")
print(f"MAE: {mae:.4f}")

# 해석
print(f"\n해석:")
print(f"- 모델은 데이터 분산의 {r2*100:.1f}%를 설명합니다.")
print(f"- 평균적으로 예측이 {rmse:.2f}만큼 빗나갑니다.")

# 기준 모델과 비교 (항상 평균값만 예측)
baseline_pred = np.full_like(y_test, y_train.mean())
baseline_r2 = r2_score(y_test, baseline_pred)
print(f"- 기준 모델 R²: {baseline_r2:.4f} (우리 모델이 {r2 - baseline_r2:.4f}만큼 개선)")

설명

이것이 하는 일: 위 코드는 선형 회귀 모델의 성능을 R², RMSE, MAE 세 가지 지표로 종합 평가합니다. 첫 번째로, 실험용 데이터를 생성합니다.

y = 2x + 3에 노이즈를 추가한 선형 관계입니다. 실제로는 이 관계를 모르는 상태에서 모델이 얼마나 잘 찾아내는지 테스트합니다.

train_test_split으로 80%는 학습, 20%는 평가용으로 나눕니다. 이것이 과적합을 발견하는 유일한 방법입니다.

그 다음으로, 모델을 학습시키고 테스트 데이터로 예측합니다. 여기서 중요한 것은 y_test(실제값)와 y_pred(예측값)를 비교한다는 점입니다.

학습에 사용되지 않은 새로운 데이터에서의 성능이 진짜 성능입니다. 마지막으로, 세 가지 지표를 계산합니다.

r2_score()는 sklearn이 자동으로 계산해줍니다. 내부적으로는 1 - (예측 오차 분산 / 실제값 분산) 공식을 사용합니다.

RMSE는 MSE에 np.sqrt()를 적용한 것입니다. MAE는 비교용으로, RMSE와 큰 차이가 나면 이상치가 많다는 신호입니다.

여러분이 실무에서 모델을 평가할 때는 이 세 가지를 항상 함께 보고합니다. R² 하나만으로는 부족합니다.

예를 들어 R²=0.9이지만 RMSE=1억이라면 실전에서 쓸 수 없습니다. 반대로 R²=0.6이지만 RMSE=100만원이라면 비즈니스 목표에 충분할 수 있습니다.

기준 모델(baseline)과 비교하는 것도 중요합니다. "우리 모델이 단순 평균보다 얼마나 나은가?"를 보여줘야 설득력이 있습니다.

실전 팁

💡 R²는 변수를 추가할수록 무조건 증가합니다. 따라서 조정된 R²(Adjusted R²)를 함께 보세요. 변수 개수를 고려한 지표입니다.

💡 교차 검증(Cross-Validation)을 사용하면 더 신뢰할 수 있는 평가를 할 수 있습니다. cross_val_score() 함수로 5-fold CV를 쉽게 할 수 있습니다.

💡 RMSE는 이상치에 민감합니다. 만약 몇 개의 큰 오차가 전체 RMSE를 높인다면, MAE를 주 지표로 사용하는 것이 나을 수 있습니다.

💡 비즈니스 지표와 연결하세요. "RMSE 2400만원이 고객 만족도에 어떤 영향을 주는가?"를 논의해야 합니다.

💡 시각화는 필수입니다. plt.scatter(y_test, y_pred)로 실제값 vs 예측값 그래프를 그려보면, 숫자만으로는 알 수 없는 패턴을 발견할 수 있습니다.

---

8. 실전_예제_주택_가격_예측

시작하며

여러분이 부동산 스타트업에 입사했다고 상상해보세요. 첫 프로젝트는 "주택 가격 자동 예측 시스템" 개발입니다.

과거 거래 데이터가 수천 건 있고, 평수, 방 개수, 욕실 개수, 건축 연도, 위치 등 다양한 정보가 포함되어 있습니다. 이 데이터로 새로운 매물의 적정 가격을 예측해야 합니다.

지금까지 배운 모든 개념을 종합하여 실전 프로젝트를 완성해봅시다. 데이터 전처리부터 모델 학습, 평가, 해석까지 전체 파이프라인을 경험할 수 있습니다.

이것이 바로 실무에서 데이터 과학자가 하는 일입니다. 단순히 코드를 작성하는 것이 아니라, 문제를 정의하고, 데이터를 이해하고, 최적의 모델을 찾아내는 것이죠.

개요

간단히 말해서, 이 예제는 실제 주택 데이터를 사용하여 가격 예측 모델을 처음부터 끝까지 만드는 완전한 프로젝트입니다. 전체 프로세스는 다음과 같습니다.

1. 데이터 로드 및 탐색: 어떤 변수가 있는지, 결측치는 없는지 확인. 2) 데이터 전처리: 결측치 처리, 범주형 변수 인코딩, 특성 스케일링.

2. 학습/테스트 분리: 과적합 방지를 위한 필수 단계. 4) 모델 학습: 다중 선형 회귀로 패턴 학습.

3. 모델 평가: R², RMSE로 성능 측정. 6) 결과 해석: 어떤 변수가 가장 중요한지 분석.

4. 예측: 새로운 주택 가격 예측. 실무에서는 여기에 더해 데이터 시각화, 이상치 제거, 변수 선택, 하이퍼파라미터 튜닝, 모델 앙상블 등이 추가됩니다.

하지만 이 예제에서 다루는 기본 파이프라인이 가장 중요합니다. 이 프로젝트를 완료하면 여러분은 "선형 회귀를 실무에 적용할 수 있다"고 자신 있게 말할 수 있습니다.

포트폴리오에 포함시켜도 좋은 수준입니다.

코드 예제

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import r2_score, mean_squared_error

# 1. 데이터 준비 (실제로는 CSV 파일 로드)
data = pd.DataFrame({
    '평수': [25, 30, 35, 28, 32, 40, 22, 38, 27, 33],
    '방개수': [2, 3, 3, 2, 3, 4, 2, 3, 2, 3],
    '욕실': [1, 2, 2, 1, 2, 3, 1, 2, 1, 2],
    '건축년도': [2010, 2015, 2018, 2012, 2017, 2020, 2008, 2019, 2011, 2016],
    '역세권': [1, 1, 0, 1, 1, 1, 0, 1, 1, 0],  # 1=yes, 0=no
    '가격': [3.8, 4.5, 5.2, 4.0, 4.8, 6.5, 3.2, 5.8, 3.9, 5.0]  # 억원
})

# 2. 데이터 전처리
X = data.drop('가격', axis=1)
y = data['가격']

# 3. 학습/테스트 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 4. 특성 스케일링
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 5. 모델 학습
model = LinearRegression()
model.fit(X_train_scaled, y_train)

# 6. 예측 및 평가
y_pred = model.predict(X_test_scaled)
r2 = r2_score(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))

print(f"R² 점수: {r2:.4f}")
print(f"RMSE: {rmse:.4f}억 원 (약 {rmse*10000:.0f}만원)")

# 7. 변수 중요도 분석
importance = pd.DataFrame({
    '변수': X.columns,
    '계수': model.coef_
}).sort_values('계수', key=abs, ascending=False)
print("\n변수 중요도:")
print(importance)

# 8. 새 주택 가격 예측
new_house = pd.DataFrame({
    '평수': [31], '방개수': [3], '욕실': [2],
    '건축년도': [2016], '역세권': [1]
})
new_house_scaled = scaler.transform(new_house)
predicted_price = model.predict(new_house_scaled)
print(f"\n새 주택 예상 가격: {predicted_price[0]:.2f}억 원")

설명

이것이 하는 일: 위 코드는 주택 데이터를 사용하여 가격 예측 모델을 만드는 전체 과정을 보여주는 종합 예제입니다. 첫 번째로, 데이터를 준비합니다.

실무에서는 pd.read_csv('housing.csv')로 대용량 CSV를 로드하지만, 여기서는 간단히 DataFrame을 직접 만듭니다. 중요한 것은 수치형 변수(평수, 건축년도)와 범주형 변수(역세권)가 섞여 있다는 점입니다.

범주형은 이미 0/1로 인코딩되어 있습니다. 그 다음으로, X(입력 특성)와 y(예측 대상)를 분리합니다.

drop('가격')으로 가격을 제외한 모든 열이 X가 됩니다. 그리고 train_test_split으로 데이터를 나눕니다.

random_state=42는 재현 가능한 결과를 위한 시드값입니다. 같은 코드를 다시 실행해도 같은 결과가 나옵니다.

세 번째로, StandardScaler로 특성을 스케일링합니다. 주의할 점은 학습 데이터로 fit한 후, 같은 scaler로 테스트 데이터를 transform한다는 것입니다.

테스트 데이터로 fit하면 데이터 누수가 발생합니다. 네 번째로, 모델을 학습시키고 평가합니다.

fit() 한 줄로 학습이 끝나고, predict()로 예측합니다. R²와 RMSE를 계산하여 "이 모델이 실전에 쓸만한가?"를 판단합니다.

RMSE를 만원 단위로 변환하면 더 직관적입니다. 다섯 번째로, 계수를 분석합니다.

model.coef_는 각 변수의 기울기를 담고 있습니다. 절댓값이 클수록 중요한 변수입니다.

예를 들어 평수의 계수가 0.8이라면 "다른 조건이 같을 때 평수 1단위(표준편차) 증가 시 가격이 0.8억 증가"를 의미합니다. 마지막으로, 새로운 주택의 가격을 예측합니다.

반드시 같은 scaler로 transform해야 합니다. 그렇지 않으면 스케일이 다른 값이 입력되어 엉뚱한 예측이 나옵니다.

여러분이 이 코드를 자신의 데이터에 적용하려면 CSV 파일 경로만 바꾸면 됩니다. 변수 이름과 개수가 달라도 같은 구조가 작동합니다.

실무에서는 이것을 기반으로 탐색적 데이터 분석(EDA), 교차 검증, 하이퍼파라미터 튜닝을 추가하면 더 강력한 시스템이 됩니다. 이 8단계 파이프라인은 모든 회귀 문제의 템플릿으로 사용할 수 있습니다.

실전 팁

💡 실무 데이터는 결측치가 많습니다. data.isnull().sum()으로 확인하고, fillna()나 dropna()로 처리하세요.

💡 EDA(탐색적 데이터 분석)를 먼저 하세요. data.describe(), data.corr(), sns.pairplot()로 데이터를 이해한 후 모델링을 시작하세요.

💡 Pipeline을 사용하면 스케일링과 모델을 하나로 묶을 수 있습니다. make_pipeline(StandardScaler(), LinearRegression())처럼 간결하게 작성할 수 있습니다.

💡 교차 검증으로 더 robust한 평가를 하세요. cross_val_score(model, X, y, cv=5)로 5번 반복 평가한 평균을 봅니다.

💡 이 코드를 Jupyter Notebook에 작성하고, 시각화를 추가하면 훌륭한 포트폴리오가 됩니다. 각 단계마다 그래프와 설명을 달아보세요.

---