릿지(Lidge), 라쏘(Lasso), 엘라스틱넷(Elastic net) 규제

릿지(Ridge)와 라쏘(Lasso)는 선형 회귀 모델에서 사용되는 규제(regularization) 기법입니다. 이들은 모델의 복잡성을 제어하고, 과적합(Overfitting)을 방지하기 위해 사용됩니다.

 

릿지(Ridge)

• L2 규제
• 파라미터(가중치)의 제곱에 피례하는 패널티 부과

릿지 회귀 비용함수

 

라쏘(Rasso)

• L1 규제
• 파라미터(가중치)의 절댓값에 비례하는 패널티 부과

 

라쏘 회귀 비용함수

 

 

엘라스틱넷(Elastic net)

• 릿지와 라쏘의 혼합
• r = 0이면 릿지 회귀와 같고, r = 1이면 라쏘 회귀와 같음

엘라스틱넷 비용함수

 

 

릿지가 기본이 되지만 쓰이는 특성이 몇 개 뿐이라고 의심되면 라쏘나 엘라스틱넷이 낫다

 

조기종료

from copy import deepcopy

poly_scaler = Pipeline([
        ("poly_features", PolynomialFeatures(degree=90, include_bias=False)),
        ("std_scaler", StandardScaler())
    ])

X_train_poly_scaled = poly_scaler.fit_transform(X_train)
X_val_poly_scaled = poly_scaler.transform(X_val)

sgd_reg = SGDRegressor(max_iter=1, warm_start=True,
                       penalty=None, learning_rate="constant", eta0=0.0005, random_state=42)

minimum_val_error = float("inf")
best_epoch = None
best_model = None
for epoch in range(1000):
    sgd_reg.fit(X_train_poly_scaled, y_train)  # 중지된 곳에서 다시 시작합니다
    y_val_predict = sgd_reg.predict(X_val_poly_scaled)
    val_error = mean_squared_error(y_val, y_val_predict)
    if val_error < minimum_val_error:
        minimum_val_error = val_error
        best_epoch = epoch
        best_model = deepcopy(sgd_reg)

위 코드는 에러남

 

ChatGPT에서 조기종료 코드 작성

from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.base import clone

# 데이터셋 분할
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

# PolynomialFeatures와 StandardScaler를 사용한 전처리 파이프라인
poly_scaler = Pipeline([
    ("poly_features", PolynomialFeatures(degree=90, include_bias=False)),
    ("std_scaler", StandardScaler())
])

X_train_poly_scaled = poly_scaler.fit_transform(X_train)
X_val_poly_scaled = poly_scaler.transform(X_val)

# Ridge 모델
ridge_reg = Ridge(alpha=1, random_state=42)

# Lasso 모델
lasso_reg = Lasso(alpha=1, random_state=42)

# ElasticNet 모델
elastic_net = ElasticNet(alpha=1, l1_ratio=0.5, random_state=42)

# 최적 모델 초기화
best_model = None
best_val_error = float("inf")
patience = 5  # 조기 종료를 위한 참을성 값 설정
no_improvement_count = 0

# 조기 종료 반복 루프
for epoch in range(1000):
    # Ridge 모델
    ridge_reg.fit(X_train_poly_scaled, y_train)
    y_val_predict_ridge = ridge_reg.predict(X_val_poly_scaled)
    val_error_ridge = mean_squared_error(y_val, y_val_predict_ridge)

    # Lasso 모델
    lasso_reg.fit(X_train_poly_scaled, y_train)
    y_val_predict_lasso = lasso_reg.predict(X_val_poly_scaled)
    val_error_lasso = mean_squared_error(y_val, y_val_predict_lasso)

    # ElasticNet 모델
    elastic_net.fit(X_train_poly_scaled, y_train)
    y_val_predict_elastic = elastic_net.predict(X_val_poly_scaled)
    val_error_elastic = mean_squared_error(y_val, y_val_predict_elastic)

    # 조기 종료 검사
    if val_error_ridge < best_val_error or val_error_lasso < best_val_error or val_error_elastic < best_val_error:
        best_val_error = min(val_error_ridge, val_error_lasso, val_error_elastic)
        best_model = clone(ridge_reg) if val_error_ridge == best_val_error else (
            clone(lasso_reg) if val_error_lasso == best_val_error else clone(elastic_net)
        )
        no_improvement_count = 0
    else:
        no_improvement_count += 1
        if no_improvement_count >= patience:
            print("조기 종료!")
            break

# 최적 모델 사용 예시
X_test_poly_scaled = poly_scaler.transform(X_test)
y_test_predict = best_model.predict(X_test_poly_scaled