파이썬 회귀분석 및 예측 라이브러리 N가지

데이터 사이언스와 머신러닝 분야에서 회귀분석과 예측은 가장 핵심적인 작업입니다. 파이썬 생태계에는 이러한 작업을 수행할 수 있는 다양한 라이브러리가 존재하며, 각각 고유한 강점과 사용 사례를 가지고 있습니다. 이 글에서는 전통적인 통계 모델부터 최신 딥러닝 기반 시계열 예측까지, 실무에서 활용 가능한 16가지 주요 라이브러리를 상세히 소개합니다.

 

 

 

 

 

 

 

1부: 전통적 통계/머신러닝

---

 

 

1. scikit-learn

한 줄 요약: 파이썬 머신러닝의 표준이자 필수 라이브러리

 

scikit-learn은 파이썬 머신러닝 생태계에서 가장 널리 사용되는 라이브러리로, 2007년 Google Summer of Code 프로젝트로 시작되어 현재까지 활발하게 유지보수되고 있습니다. 이 라이브러리는 일관된 API 설계 철학을 바탕으로 분류, 회귀, 클러스터링, 차원 축소 등 다양한 머신러닝 알고리즘을 제공합니다. 선형 회귀, 릿지 회귀, 라쏘 회귀와 같은 기본적인 선형 모델부터 랜덤 포레스트, 서포트 벡터 머신까지 폭넓은 알고리즘을 지원하며, 데이터 전처리, 모델 선택, 교차 검증 등의 유틸리티 기능도 함께 제공합니다. NumPy와 SciPy를 기반으로 구축되어 있어 다른 파이썬 데이터 과학 도구들과의 호환성이 뛰어나고, 최신 버전 1.8.0에서는 Python 3.11 이상을 지원합니다.

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

xData = np.array([[1], [2], [3], [4], [5]])
yData = np.array([2.1, 4.2, 5.8, 8.1, 9.9])

xTrain, xTest, yTrain, yTest = train_test_split(xData, yData, test_size=0.2, random_state=42)

model = LinearRegression()
model.fit(xTrain, yTrain)

yPred = model.predict(xTest)
mse = mean_squared_error(yTest, yPred)
print(f"MSE: {mse:.4f}")
print(f"계수: {model.coef_[0]:.4f}, 절편: {model.intercept_:.4f}")

 

🔗 공식 링크: https://scikit-learn.org/

scikit-learn: machine learning in Python — scikit-learn 0.16.1 documentation

 

 

반응형

 

2. statsmodels

한 줄 요약: 통계학자를 위한 상세한 통계량과 추론 기능 제공

 

statsmodels는 통계적 모델링과 계량경제학에 특화된 파이썬 라이브러리입니다. scikit-learn이 예측 성능에 초점을 맞춘다면, statsmodels는 p-value, 신뢰구간, R-squared, F-통계량 등 상세한 통계적 추론 결과를 제공하는 데 강점이 있습니다. OLS(최소제곱법), GLS(일반화최소제곱법), WLS(가중최소제곱법) 등 다양한 선형 회귀 방법론을 지원하며, ARIMA와 같은 시계열 분석 모델도 포함되어 있습니다. R 스타일의 포뮬러 문법을 지원하여 R 사용자들이 쉽게 적응할 수 있으며, 회귀 분석 결과를 학술 논문이나 보고서에 활용하기 적합한 형태로 출력합니다. 금융, 경제학, 사회과학 분야에서 가설 검정과 통계적 추론이 중요한 경우에 특히 유용합니다.

import numpy as np
import statsmodels.api as sm

xData = np.array([1, 2, 3, 4, 5])
yData = np.array([2.1, 4.2, 5.8, 8.1, 9.9])

xWithConst = sm.add_constant(xData)

model = sm.OLS(yData, xWithConst)
results = model.fit()

print(results.summary())
print(f"\nR-squared: {results.rsquared:.4f}")
print(f"p-value (기울기): {results.pvalues[1]:.4f}")

 

🔗 공식 링크: https://www.statsmodels.org/

https://www.statsmodels.org/

 

 

 

 

3. XGBoost

한 줄 요약: Kaggle 대회 우승의 단골 손님, 그래디언트 부스팅의 대명사

 

XGBoost(eXtreme Gradient Boosting)는 2014년 Tianqi Chen이 개발한 그래디언트 부스팅 라이브러리로, 정형 데이터 예측에서 뛰어난 성능을 보여줍니다. 2015년 Kaggle 대회에서 29개 우승 솔루션 중 17개가 XGBoost를 사용했을 정도로 그 성능이 입증되었습니다. 이 라이브러리는 트리 기반 앙상블 모델을 구축하며, 각 새로운 트리가 이전 트리들의 오류를 수정하는 방식으로 학습합니다. L1/L2 정규화를 통한 과적합 방지, 결측치 자동 처리, 병렬 처리를 통한 빠른 학습 속도가 주요 특징입니다. CPU와 GPU 모두 지원하며, Hadoop, Spark, Dask 등 분산 환경에서도 동작합니다. scikit-learn 호환 API를 제공하여 기존 파이프라인에 쉽게 통합할 수 있습니다.

import numpy as np
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

xData = np.random.rand(100, 5)
yData = np.sum(xData, axis=1) + np.random.randn(100) * 0.1

xTrain, xTest, yTrain, yTest = train_test_split(xData, yData, test_size=0.2, random_state=42)

dTrain = xgb.DMatrix(xTrain, label=yTrain)
dTest = xgb.DMatrix(xTest, label=yTest)

params = {
    "objective": "reg:squarederror",
    "max_depth": 3,
    "eta": 0.1
}

model = xgb.train(params, dTrain, num_boost_round=100)

yPred = model.predict(dTest)
rmse = np.sqrt(mean_squared_error(yTest, yPred))
print(f"RMSE: {rmse:.4f}")

 

🔗 공식 링크: https://github.com/dmlc/xgboost

GitHub - dmlc/xgboost: Scalable, Portable and Distributed Gradient Boosting (GBDT, GBRT or GBM) Library, for Python, R, Java, S

 

 

 

 

728x90

 

 

4. LightGBM

한 줄 요약: Microsoft가 개발한 빠르고 메모리 효율적인 그래디언트 부스팅

 

LightGBM은 Microsoft에서 개발한 그래디언트 부스팅 프레임워크로, XGBoost보다 빠른 학습 속도와 낮은 메모리 사용량이 특징입니다. Leaf-wise 트리 성장 방식을 채택하여 Level-wise 방식보다 더 깊은 트리를 효율적으로 생성할 수 있습니다. 히스토그램 기반 알고리즘을 사용하여 연속형 변수를 이산화함으로써 메모리 사용량을 크게 줄이고 학습 속도를 향상시켰습니다. 범주형 변수를 원-핫 인코딩 없이 직접 처리할 수 있어 전처리 과정이 간소화되며, 이는 원-핫 인코딩 대비 약 8배 빠른 속도를 제공합니다. 대용량 데이터셋과 고차원 피처가 있는 실무 환경에서 특히 강점을 발휘하며, GPU 학습과 분산 학습도 지원합니다.

import numpy as np
import lightgbm as lgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

xData = np.random.rand(1000, 10)
yData = np.sum(xData[:, :3], axis=1) + np.random.randn(1000) * 0.1

xTrain, xTest, yTrain, yTest = train_test_split(xData, yData, test_size=0.2, random_state=42)

trainData = lgb.Dataset(xTrain, label=yTrain)
validData = lgb.Dataset(xTest, label=yTest, reference=trainData)

params = {
    "objective": "regression",
    "metric": "rmse",
    "num_leaves": 31,
    "learning_rate": 0.05,
    "verbosity": -1
}

model = lgb.train(
    params,
    trainData,
    num_boost_round=100,
    valid_sets=[validData]
)

yPred = model.predict(xTest)
rmse = np.sqrt(mean_squared_error(yTest, yPred))
print(f"RMSE: {rmse:.4f}")

 

🔗 공식 링크: https://github.com/microsoft/LightGBM

GitHub - microsoft/LightGBM: A fast, distributed, high performance gradient boosting (GBT, GBDT, GBRT, GBM or MART) framework ba

 

 

 

 

5. CatBoost

한 줄 요약: 범주형 변수 처리의 강자, Yandex가 만든 그래디언트 부스팅

 

CatBoost는 러시아의 기술 기업 Yandex가 개발한 그래디언트 부스팅 라이브러리로, 이름에서 알 수 있듯이 범주형(Categorical) 변수 처리에 특화되어 있습니다. 기존 그래디언트 부스팅 모델들은 범주형 변수를 원-핫 인코딩이나 레이블 인코딩으로 변환해야 했지만, CatBoost는 Ordered Target Statistics라는 독자적인 방법으로 범주형 변수를 직접 처리합니다. 이로 인해 데이터 전처리 과정이 대폭 간소화되고, 범주형 변수가 많은 실제 비즈니스 데이터에서 뛰어난 성능을 보입니다. Ordered Boosting 기법을 통해 예측 편향을 줄이고, 대칭 트리(Symmetric Tree) 구조를 사용하여 예측 속도를 크게 향상시켰습니다. CPU와 GPU 모두 지원하며, 모델 해석을 위한 다양한 시각화 도구도 내장되어 있습니다.

import numpy as np
from catboost import CatBoostRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

xData = np.random.rand(500, 5)
yData = np.sum(xData, axis=1) + np.random.randn(500) * 0.1

xTrain, xTest, yTrain, yTest = train_test_split(xData, yData, test_size=0.2, random_state=42)

model = CatBoostRegressor(
    iterations=100,
    learning_rate=0.1,
    depth=6,
    verbose=False
)

model.fit(xTrain, yTrain)

yPred = model.predict(xTest)
rmse = np.sqrt(mean_squared_error(yTest, yPred))
print(f"RMSE: {rmse:.4f}")
print(f"Feature Importances: {model.get_feature_importance()}")

 

 

🔗 공식 링크: https://catboost.ai/

CatBoost - state-of-the-art open-source gradient boosting library with categorical features support

 

 

 

 

 

 

 

2부: 시계열 예측

---

 

 

 

 

6. Prophet

한 줄 요약: Meta(Facebook)가 만든 직관적이고 사용하기 쉬운 시계열 예측 도구

 

Prophet은 Meta(구 Facebook)의 Core Data Science 팀이 개발한 시계열 예측 라이브러리로, 비즈니스 데이터의 특성을 잘 반영하도록 설계되었습니다. 가법 모델(Additive Model)을 기반으로 트렌드, 계절성(연간/주간/일간), 휴일 효과를 분리하여 모델링합니다. 통계학이나 시계열 분석에 대한 깊은 지식 없이도 몇 줄의 코드로 합리적인 예측 결과를 얻을 수 있어 실무자들 사이에서 인기가 높습니다. 결측치와 이상치에 강건하며, 트렌드의 변화점(Changepoint)을 자동으로 탐지합니다. 계절성이 강하고 여러 시즌의 과거 데이터가 있는 시계열에서 특히 좋은 성능을 보이며, 수동 튜닝을 통해 도메인 지식을 모델에 반영할 수 있습니다. Python과 R 모두 지원합니다.

import pandas as pd
import numpy as np
from prophet import Prophet

df = pd.DataFrame({
    "ds": pd.date_range(start="2020-01-01", periods=365, freq="D"),
    "y": [100 + i * 0.5 + 20 * np.sin(2 * np.pi * i / 365) + np.random.randn() * 5 
          for i in range(365)]
})

model = Prophet(
    yearly_seasonality=True,
    weekly_seasonality=True,
    daily_seasonality=False
)
model.fit(df)

futureData = model.make_future_dataframe(periods=30)
forecast = model.predict(futureData)

print(forecast[["ds", "yhat", "yhat_lower", "yhat_upper"]].tail())

 

🔗 공식 링크: https://facebook.github.io/prophet/

Prophet

 

 

 

7. TimesFM

한 줄 요약: Google Research의 사전학습 시계열 파운데이션 모델, 제로샷 예측 가능

 

TimesFM(Time Series Foundation Model)은 Google Research에서 개발한 시계열 예측을 위한 파운데이션 모델입니다. 1000억 개 이상의 실제 시계열 데이터 포인트로 사전 학습되어, 새로운 데이터셋에 대해 추가 학습 없이도 제로샷 예측이 가능합니다. 2억 개의 파라미터를 가진 디코더 전용 트랜스포머 구조를 기반으로 하며, 패칭(Patching) 기법을 활용하여 다양한 컨텍스트 길이와 예측 구간에 유연하게 대응합니다. ICML 2024에서 발표되었으며, Monash Archive, Darts 벤치마크 등에서 기존 지도학습 모델들과 비교해도 경쟁력 있는 성능을 보입니다. 최신 버전 2.5에서는 최대 1024 타임스텝의 컨텍스트와 256 타임스텝의 예측 구간을 지원하며, 외부 변수(Covariate) 지원과 파인튜닝 기능도 제공합니다.

import numpy as np
import torch
import timesfm

torch.set_float32_matmul_precision("high")

model = timesfm.TimesFM_2p5_200M_torch.from_pretrained("google/timesfm-2.5-200m-pytorch")
model.compile(
    timesfm.ForecastConfig(
        max_context=512,
        max_horizon=128,
        normalize_inputs=True
    )
)

inputSeries = [
    np.sin(np.linspace(0, 4 * np.pi, 100)),
    np.linspace(0, 1, 50) + np.random.randn(50) * 0.1
]

pointForecast, quantileForecast = model.forecast(
    horizon=30,
    inputs=inputSeries
)

print(f"Point Forecast Shape: {pointForecast.shape}")
print(f"Quantile Forecast Shape: {quantileForecast.shape}")

 

🔗 공식 링크: https://github.com/google-research/timesfm

GitHub - google-research/timesfm: TimesFM (Time Series Foundation Model) is a pretrained time-series foundation model developed

 

 

 

 

8. statsmodels ARIMA

한 줄 요약: 전통적인 Box-Jenkins 방법론 기반의 시계열 분석 도구

 

statsmodels의 시계열 분석 모듈은 ARIMA(AutoRegressive Integrated Moving Average)를 비롯한 전통적인 시계열 모델을 제공합니다. ARIMA는 자기회귀(AR), 차분(I), 이동평균(MA) 세 가지 구성요소를 결합한 모델로, 시계열 데이터의 패턴을 수학적으로 명확하게 표현할 수 있습니다. SARIMA(Seasonal ARIMA)를 통해 계절성도 모델링할 수 있으며, SARIMAX는 외생 변수까지 포함할 수 있습니다. 이러한 모델들은 통계적 근거가 명확하고 해석이 용이하여 학술 연구와 금융 분야에서 여전히 널리 사용됩니다. ACF/PACF 분석, ADF 검정 등 시계열 진단 도구도 함께 제공되어 모델 적합성을 검증할 수 있습니다. 데이터가 정상성(Stationarity)을 만족해야 한다는 전제조건이 있어 전처리가 중요합니다.

import numpy as np
import pandas as pd
from statsmodels.tsa.arima.model import ARIMA
import warnings
warnings.filterwarnings("ignore")

np.random.seed(42)
dateIndex = pd.date_range(start="2020-01-01", periods=200, freq="D")
tsData = pd.Series(
    [100 + i * 0.3 + np.random.randn() * 5 for i in range(200)],
    index=dateIndex
)

trainData = tsData[:170]
testData = tsData[170:]

model = ARIMA(trainData, order=(2, 1, 2))
fittedModel = model.fit()

forecast = fittedModel.forecast(steps=30)

print(fittedModel.summary())
print(f"\n예측값 (처음 5개): {forecast.values[:5]}")

 

🔗 공식 링크: https://www.statsmodels.org/stable/tsa.html

Time Series analysis tsa - statsmodels 0.14.6

 

 

 

 

9. Darts

한 줄 요약: 시계열의 scikit-learn을 목표로 하는 통합 예측 라이브러리

 

Darts는 스위스의 AI 컨설팅 회사 Unit8에서 개발한 시계열 분석 및 예측 라이브러리입니다. ARIMA부터 딥러닝 모델까지 다양한 시계열 모델을 일관된 API로 제공하여, 마치 scikit-learn처럼 fit()과 predict() 메서드만으로 다양한 모델을 손쉽게 비교할 수 있습니다. 단변량/다변량 시계열, 확률적 예측, 공변량(Covariate) 지원 등 실무에서 필요한 기능을 포괄적으로 제공합니다. 내장된 모델로는 ExponentialSmoothing, ARIMA, Prophet, Theta, 그리고 LSTM, TCN, N-BEATS, Temporal Fusion Transformer 등의 딥러닝 모델이 있습니다. PyTorch Lightning 기반으로 구현되어 GPU 학습이 가능하며, 백테스팅, 모델 앙상블, 이상 탐지 기능도 지원합니다. 시계열 데이터를 위한 자체 TimeSeries 클래스를 제공하여 데이터 처리가 편리합니다.

import numpy as np
import pandas as pd
from darts import TimeSeries
from darts.models import ExponentialSmoothing

dateRange = pd.date_range(start="2020-01-01", periods=365, freq="D")
values = [100 + i * 0.2 + 30 * np.sin(2 * np.pi * i / 365) + np.random.randn() * 5 
          for i in range(365)]

series = TimeSeries.from_dataframe(
    pd.DataFrame({"date": dateRange, "value": values}),
    time_col="date",
    value_cols="value"
)

trainSeries, testSeries = series.split_after(0.8)

model = ExponentialSmoothing()
model.fit(trainSeries)

prediction = model.predict(len(testSeries))

print(f"예측 기간: {len(prediction)} 일")
print(f"예측값 (처음 5개): {prediction.values()[:5].flatten()}")

 

🔗 공식 링크: https://unit8co.github.io/darts/

Time Series Made Easy in Python — darts documentation

 

 

 

10. NeuralProphet

한 줄 요약: Prophet과 딥러닝의 만남, 자기회귀 기능이 추가된 신경망 시계열 모델

 

NeuralProphet은 Facebook Prophet의 직관적인 인터페이스와 PyTorch 기반 딥러닝의 유연성을 결합한 시계열 예측 프레임워크입니다. Stanford 대학과 Facebook, Monash 대학의 협력으로 개발되었으며, Prophet의 가법 모델 구조를 유지하면서 AR-Net을 통한 자기회귀 모델링 기능을 추가했습니다. 경사하강법(Gradient Descent)을 사용하여 Prophet보다 빠른 학습이 가능하며, 지연된 회귀 변수(Lagged Regressors)를 신경망으로 모델링할 수 있습니다. 트렌드, 계절성, 자기회귀, 외부 변수 효과 등 각 구성요소를 시각화하여 모델의 예측 근거를 해석할 수 있습니다. 일별 이하의 고빈도 데이터와 2년 이상의 장기 시계열에서 특히 좋은 성능을 보이며, 반복적인 모델 개선 워크플로우에 적합하게 설계되었습니다.

import pandas as pd
import numpy as np
from neuralprophet import NeuralProphet

df = pd.DataFrame({
    "ds": pd.date_range(start="2020-01-01", periods=730, freq="D"),
    "y": [100 + i * 0.1 + 20 * np.sin(2 * np.pi * i / 365) + np.random.randn() * 3 
          for i in range(730)]
})

model = NeuralProphet(
    growth="linear",
    yearly_seasonality=True,
    weekly_seasonality=True,
    daily_seasonality=False,
    n_forecasts=7,
    n_lags=14,
    epochs=100
)

metrics = model.fit(df, freq="D")

futureData = model.make_future_dataframe(df, periods=30)
forecast = model.predict(futureData)

print(f"학습 Loss: {metrics['Loss'].iloc[-1]:.4f}")
print(forecast[["ds", "yhat1"]].tail())

 

🔗 공식 링크: https://neuralprophet.com/

NeuralProphet

 

 

 

 

3부: 딥러닝 기반

---

 

 

11. TensorFlow/Keras

한 줄 요약: Google이 개발한 산업 표준 딥러닝 프레임워크

 

TensorFlow는 Google Brain 팀이 개발한 오픈소스 딥러닝 프레임워크로, 대규모 머신러닝 모델의 학습과 배포에 최적화되어 있습니다. Keras는 TensorFlow의 고수준 API로, 직관적인 인터페이스를 통해 복잡한 신경망 모델을 몇 줄의 코드로 구축할 수 있습니다. 시계열 예측을 위해 LSTM, GRU 등의 순환 신경망(RNN)이나 1D CNN, Transformer 아키텍처를 쉽게 구현할 수 있습니다. TensorFlow Extended(TFX)를 통해 모델 학습부터 서빙까지 엔드투엔드 파이프라인을 구축할 수 있으며, TensorFlow Lite로 모바일/엣지 디바이스 배포도 지원합니다. GPU, TPU 학습을 기본 지원하고, 분산 학습 전략도 다양하게 제공합니다. 프로덕션 환경에서의 안정성과 확장성이 검증되어 기업에서 널리 사용됩니다.

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

def createSequences(data, seqLength):
    """시퀀스 데이터 생성"""
    xSeq, ySeq = [], []
    for i in range(len(data) - seqLength):
        xSeq.append(data[i:i + seqLength])
        ySeq.append(data[i + seqLength])
    return np.array(xSeq), np.array(ySeq)

data = np.sin(np.linspace(0, 20 * np.pi, 500)) + np.random.randn(500) * 0.1
seqLength = 20

xData, yData = createSequences(data, seqLength)
xData = xData.reshape((xData.shape[0], xData.shape[1], 1))

splitIdx = int(len(xData) * 0.8)
xTrain, xTest = xData[:splitIdx], xData[splitIdx:]
yTrain, yTest = yData[:splitIdx], yData[splitIdx:]

model = Sequential([
    LSTM(50, activation="relu", input_shape=(seqLength, 1)),
    Dense(1)
])
model.compile(optimizer="adam", loss="mse")
model.fit(xTrain, yTrain, epochs=20, batch_size=32, verbose=0)

yPred = model.predict(xTest, verbose=0)
mse = np.mean((yTest - yPred.flatten()) ** 2)
print(f"Test MSE: {mse:.4f}")

 

🔗 공식 링크: https://www.tensorflow.org/

TensorFlow

 

 

 

 

12. PyTorch

한 줄 요약: 연구자들이 사랑하는 동적 계산 그래프 기반 딥러닝 프레임워크

 

PyTorch는 Meta(구 Facebook) AI Research에서 개발한 오픈소스 딥러닝 프레임워크로, 동적 계산 그래프(Dynamic Computational Graph)를 특징으로 합니다. 이 특징 덕분에 파이썬의 제어 흐름(if, while 등)을 자연스럽게 사용할 수 있어 디버깅이 쉽고 실험적인 모델 개발에 유리합니다. 학계에서 발표되는 최신 딥러닝 논문들의 구현체 대부분이 PyTorch로 작성되어, 새로운 기법을 빠르게 적용할 수 있습니다. 시계열 예측에서는 LSTM, GRU, Transformer 등을 직접 구현하거나 기존 모듈을 조합하여 커스텀 모델을 만들 수 있습니다. TorchScript를 통해 모델을 최적화하고 C++에서 실행할 수 있으며, ONNX 형식으로 내보내 다른 프레임워크에서 사용할 수도 있습니다.

import numpy as np
import torch
import torch.nn as nn

class LSTMRegressor(nn.Module):
    def __init__(self, inputSize, hiddenSize, numLayers):
        super().__init__()
        self.lstm = nn.LSTM(inputSize, hiddenSize, numLayers, batch_first=True)
        self.fc = nn.Linear(hiddenSize, 1)
    
    def forward(self, x):
        lstmOut, _ = self.lstm(x)
        out = self.fc(lstmOut[:, -1, :])
        return out

seqLength = 20
data = np.sin(np.linspace(0, 10 * np.pi, 300)).astype(np.float32)

xData = np.array([data[i:i+seqLength] for i in range(len(data)-seqLength)])
yData = data[seqLength:]
xTensor = torch.FloatTensor(xData).unsqueeze(-1)
yTensor = torch.FloatTensor(yData).unsqueeze(-1)

model = LSTMRegressor(inputSize=1, hiddenSize=32, numLayers=2)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

for epoch in range(100):
    model.train()
    optimizer.zero_grad()
    output = model(xTensor)
    loss = criterion(output, yTensor)
    loss.backward()
    optimizer.step()

print(f"Final Loss: {loss.item():.4f}")

 

🔗 공식 링크: https://pytorch.org/

PyTorch

 

 

 

13. PyTorch Forecasting

한 줄 요약: 시계열 딥러닝의 best practice를 집대성한 고수준 라이브러리

 

PyTorch Forecasting은 PyTorch Lightning 기반의 시계열 예측 전문 라이브러리로, 최신 딥러닝 시계열 모델들을 실무에 바로 적용할 수 있도록 설계되었습니다. Temporal Fusion Transformer(TFT), N-BEATS, N-HiTS, DeepAR 등 학술적으로 검증된 아키텍처들을 일관된 API로 제공합니다. 특히 TFT는 Amazon의 DeepAR 대비 36-69% 향상된 성능을 벤치마크에서 보여주었습니다. TimeSeriesDataSet 클래스를 통해 변수 변환, 결측치 처리, 서브샘플링, 다양한 히스토리 길이 등을 자동으로 처리해주어 데이터 전처리의 복잡성을 크게 줄여줍니다. 모델 해석을 위한 시각화 도구가 내장되어 있어 예측 결과의 변수별 기여도를 분석할 수 있습니다. GPU/TPU 학습과 TensorBoard 로깅이 기본 지원됩니다.

import numpy as np
import pandas as pd
import lightning.pytorch as pl
from pytorch_forecasting import TimeSeriesDataSet, TemporalFusionTransformer
from pytorch_forecasting.metrics import QuantileLoss

dates = pd.date_range("2020-01-01", periods=500, freq="D")
df = pd.DataFrame({
    "time_idx": range(500),
    "target": np.sin(np.linspace(0, 10*np.pi, 500)) * 10 + 50 + np.random.randn(500),
    "group_id": "series1",
    "date": dates
})

maxEncoderLength = 60
maxPredictionLength = 20
trainingCutoff = df["time_idx"].max() - maxPredictionLength

training = TimeSeriesDataSet(
    df[df.time_idx <= trainingCutoff],
    time_idx="time_idx",
    target="target",
    group_ids=["group_id"],
    max_encoder_length=maxEncoderLength,
    max_prediction_length=maxPredictionLength
)

trainDataloader = training.to_dataloader(train=True, batch_size=32, num_workers=0)

model = TemporalFusionTransformer.from_dataset(
    training,
    learning_rate=0.03,
    hidden_size=16,
    attention_head_size=1,
    dropout=0.1,
    loss=QuantileLoss()
)

print(f"모델 파라미터 수: {sum(p.numel() for p in model.parameters()):,}")

 

🔗 공식 링크: https://github.com/sktime/pytorch-forecasting

GitHub - sktime/pytorch-forecasting: Time series forecasting with PyTorch

 

 

 

 

4부: AutoML

---

 

 

 

 

14. Auto-sklearn

한 줄 요약: scikit-learn 기반 자동 모델 선택 및 하이퍼파라미터 튜닝

 

Auto-sklearn은 scikit-learn을 기반으로 한 AutoML 프레임워크로, 알고리즘 선택과 하이퍼파라미터 튜닝을 자동화합니다. 베이지안 최적화를 사용하여 최적의 머신러닝 파이프라인을 효율적으로 탐색하며, 메타러닝(Meta-learning)을 통해 유사한 데이터셋에서 잘 작동했던 구성을 우선적으로 시도합니다. 자동으로 피처 전처리(원-핫 인코딩, 정규화, PCA 등)를 수행하고, 여러 모델을 앙상블하여 단일 모델보다 강건한 예측을 제공합니다. AutoML 연구의 선구자적 역할을 했으며, 많은 학술 논문에서 베이스라인으로 사용됩니다. 다만 복잡한 데이터셋에서는 상당한 계산 자원이 필요할 수 있으며, Windows에서는 WSL을 통해서만 사용 가능합니다. 분류와 회귀 문제 모두 지원합니다.

import numpy as np
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from autosklearn.regression import AutoSklearnRegressor

xData, yData = make_regression(n_samples=500, n_features=10, noise=10, random_state=42)
xTrain, xTest, yTrain, yTest = train_test_split(xData, yData, test_size=0.2, random_state=42)

automl = AutoSklearnRegressor(
    time_left_for_this_task=120,
    per_run_time_limit=30,
    memory_limit=4096,
    n_jobs=1
)

automl.fit(xTrain, yTrain)

yPred = automl.predict(xTest)
r2Score = automl.score(xTest, yTest)

print(f"R² Score: {r2Score:.4f}")
print(f"\n최적 모델:\n{automl.show_models()}")

 

🔗 공식 링크: https://automl.github.io/auto-sklearn/

https://automl.github.io/auto-sklearn/

 

 

 

 

15. TPOT

한 줄 요약: 유전 알고리즘으로 최적의 ML 파이프라인을 진화시키는 AutoML

 

TPOT(Tree-based Pipeline Optimization Tool)은 Cedars-Sinai의 Epistasis Lab에서 개발한 AutoML 도구로, 유전 알고리즘을 사용하여 최적의 머신러닝 파이프라인을 탐색합니다. 각 파이프라인을 유전자로 표현하고, 세대를 거듭하며 선택, 교차, 돌연변이를 통해 더 나은 파이프라인으로 진화시킵니다. scikit-learn의 다양한 전처리기와 모델을 조합하여 수천 개의 파이프라인을 자동으로 평가하며, 최종적으로 선택된 파이프라인을 파이썬 코드로 내보낼 수 있어 재현성이 뛰어납니다. 원래 생물의학 데이터 분석을 위해 설계되었지만 다양한 도메인에서 활용됩니다. 유전 알고리즘 특성상 탐색에 시간이 오래 걸릴 수 있으나, 해석 가능한 단순한 파이프라인을 선호하는 경향이 있습니다. 현재 TPOT2로 발전 중입니다.

import numpy as np
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from tpot import TPOTRegressor

xData, yData = make_regression(n_samples=500, n_features=10, noise=10, random_state=42)
xTrain, xTest, yTrain, yTest = train_test_split(xData, yData, test_size=0.2, random_state=42)

tpotModel = TPOTRegressor(
    generations=5,
    population_size=20,
    cv=5,
    random_state=42,
    verbosity=2,
    n_jobs=-1
)

tpotModel.fit(xTrain, yTrain)

score = tpotModel.score(xTest, yTest)
print(f"\nTest R² Score: {score:.4f}")

tpotModel.export("best_pipeline.py")
print("최적 파이프라인이 best_pipeline.py로 저장되었습니다.")

 

🔗 공식 링크: https://epistasislab.github.io/tpot/

Redirecting

 

 

 

 

16. PyCaret

한 줄 요약: 로우코드 ML의 정수, 몇 줄로 여러 모델을 비교하고 배포까지

 

PyCaret은 머신러닝 워크플로우를 극적으로 단순화하는 로우코드(Low-Code) AutoML 라이브러리입니다. 몇 줄의 코드만으로 데이터 전처리, 모델 학습, 하이퍼파라미터 튜닝, 모델 비교, 앙상블, 배포까지 전체 머신러닝 파이프라인을 구축할 수 있습니다. setup() 함수 하나로 결측치 처리, 인코딩, 정규화, 피처 선택 등 전처리를 자동으로 수행하고, compare_models()로 수십 개의 알고리즘을 한 번에 비교합니다. 분류, 회귀, 클러스터링, 이상 탐지, NLP, 시계열 분석 등 다양한 태스크를 지원합니다. scikit-learn, XGBoost, LightGBM, CatBoost 등 인기 있는 라이브러리들과 통합되어 있으며, MLflow를 통한 실험 추적과 AWS, GCP, Azure로의 배포 기능도 제공합니다. 빠른 프로토타이핑과 실험에 이상적입니다.

import pandas as pd
import numpy as np
from pycaret.regression import setup, compare_models, tune_model, finalize_model

np.random.seed(42)
df = pd.DataFrame({
    "feature1": np.random.rand(500),
    "feature2": np.random.rand(500),
    "feature3": np.random.rand(500)
})
df["target"] = df["feature1"] * 2 + df["feature2"] * 3 + np.random.randn(500) * 0.1

regSetup = setup(
    data=df,
    target="target",
    train_size=0.8,
    session_id=42,
    verbose=False
)

bestModels = compare_models(n_select=3)

tunedModel = tune_model(bestModels[0])

finalModel = finalize_model(tunedModel)
print(f"최종 모델: {finalModel}")

 

🔗 공식 링크: https://pycaret.org/

PyCaret 3.0 | Docs

 

 

 

 

어떤 라이브러리를 선택해야 할까?

각 라이브러리는 고유한 강점을 가지고 있어, 상황에 맞는 선택이 중요합니다.

 

 

입문자 추천 학습 경로

scikit-learn → 머신러닝의 기본 개념과 워크플로우 학습 XGBoost/LightGBM → 정형 데이터 예측 성능 향상 Prophet → 시계열 예측 입문