[ML] 모델 훈련

이전까지의 실습에서 우리는 머신러닝 모델 내부가 어떻게 작동하는지 몰라도 많은 일을 처리할 수 있었습니다. 하지만 어떻게 작동하는지 잘 이해하고 있으면 작업에 맞는 하이퍼파라미터를 빠르게 찾을 수 있습니다. 또한 디버깅이나 에러를 효율적으로 분석하는 데 도움이 됩니다.

선형 회귀

가장 간단한 모델 중 하나인 선형 회귀를 통해 모델 훈련의 작동 원리를 이해해봅시다. 이 모델을 훈련시키는 두 가지 방법은 다음과 같습니다.

• 공식을 사용하여 훈련 세트에 가장 잘 맞는 모델 파라미터(훈련 세트에 대해 비용 함수를 최소화하는 모델 파라미터)를 해석적으로 계산
• 경사 하강법을 사용하여 훈련 세트에 대해 비용 함수를 최소화

선형 모델은 일반적으로 다음 식과 같이 입력 특성의 가중치 합과 편향이라는 상수를 더해 예측을 만듭니다.

• $\hat{y}$ : 예측값
• $n$ : 특성의 수
• $x_i$ : $i$번째 특성값
• $\theta_j$ : $j$번째 모델 파라미터

이 식은 다음 식과 같이 벡터 형태로 더 간단하게 표현할 수 있습니다.

• $\theta$ : 편향 $\theta_0$와 $\theta_1$에서 $\theta_n$까지의 특성 가중치를 담은 모델의 파라미터 벡터
• $x$ : $x_0$에서 $x_n$까지 담은 샘플의 특성 벡터
• $h_{\theta}$ : 모델 파라미터 theta를 사용한 가설 함수

모델을 훈련시킨다는 것은 모델이 훈련 세트에 가장 잘 맞도록 모델 파라미터를 설정하는 것입니다.

훈련하기 전에 모델이 훈련 데이터에 얼마나 잘 들어맞는지 측정해야 합니다. 회귀에 가장 널리 사용되는 성능 측정 지표인 RMSE를 사용해도 되지만 실제로 MSE가 같은 결과를 내면서 더 간단하므로 MSE를 사용하겠습니다. 훈련 세트 $X$에 대한 선형 회귀 가설 $h_{\theta}$의 MSE는 다음과 같이 계산합니다.

정규방정식

비용 함수를 최소화하는 $\theta$ 값을 찾기 위한 공식이 다음과 같이 있습니다.

• $\hat{\theta}$ : 비용 함수를 최소화하는 $\theta$ 값
• $y$: $y_{(1)}$부터 $y_{(m)}$까지 포함하는 타깃 벡터

공식을 테스트하기에 앞서 데이터를 생성하겠습니다.

import numpy as np

            X = 2 * np.random.rand(100, 1)
            y = 4 + 3 * X + np.random.randn(100, 1)

%matplotlib inline
            import matplotlib as mpl
            import matplotlib.pyplot as plt

            plt.plot(X, y, "b.")
            plt.xlabel("$x_1$", fontsize=18)
            plt.ylabel("$y$", rotation=0, fontsize=18)
            plt.axis([0, 2, 0, 15])
            plt.show()

정규방정식을 사용해 $\hat{\theta}$을 계산해봅시다.

X_b = np.c_[np.ones((100, 1)), X]
            theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)
            theta_best

$\theta_0$는 4에 근접하고, $\theta_1$은 3에 근접합니다. 이제 예측을 수행해보겠습니다.

X_new = np.array([[0], [2]])
            X_new_b = np.c_[np.ones((2, 1)), X_new]
            y_predict = X_new_b.dot(theta_best)
            y_predict

사이킷런에서는 이 과정을 더 쉽게 수행할 수 있습니다.

from sklearn.linear_model import LinearRegression

            lin_reg = LinearRegression()
            lin_reg.fit(X, y)
            print((lin_reg.intercept_, lin_reg.coef_))
            print(lin_reg.predict(X_new))

LinearRegression 클래스는 scipy.linalg.lstsq 함수(최소 제곱; least squares)를 기반으로 합니다. 이 함수를 직접 호출해 봅시다.

theta_best_svd, residuals, rank, s = np.linalg.lstsq(X_b, y, rcond=1e-6)
            theta_best_svd

이 함수는 다음과 같은 식을 계산합니다.

$X^+$는 $X$의 유사역행렬이며, np.linalg.pinv 함수를 사용해 이를 다음과 같이 직접 구할 수 있습니다.

np.linalg.pinv(X_b).dot(y)

유사역행렬 자체는 SVD를 사용해 계산됩니다. 유사역행렬은 다음과 같은 식으로 계산됩니다.

$\Sigma^+$를 계산하기 위한 알고리즘은 다음과 같습니다.

1. sigma를 구함
2. 어떤 낮은 임곗값보다 작은 모든 수를 0으로 바꿈
3. 0이 아닌 모든 값을 역수로 치환
4. 만들어진 행렬을 전치

$m < n$이거나 어떤 특성이 중복되어 행렬 $X^T * X$의 역행렬이 없다면 정규방정식이 작동하지 않는 반면에, 유사역행렬은 항상 구할 수 있습니다. 따라서, 유사역행렬을 이용하여 계산하는 방법이 훨씬 효율적입니다.

계산 복잡도

사이킷런의 LinearRegression 클래스가 사용하는 SVD 방법은 약 O($n^2$)입니다. 특성의 개수가 두 배로 늘어나면 계산 시간이 대략 4배가 됩니다.

정규방정식이나 다른 알고리즘으로 학습된 선형 회귀 모델은 예측이 매우 빠릅니다. 예측 계산 복잡도는 샘플 수와 특성 수에 선형적입니다.

경사 하강법

경사 하강법은 여러 종류의 문제에 대한 최적의 해법을 찾을 수 있는 일반적인 최적화 알고리즘입니다.

경사 하강법의 기본 아이디어는 비용 함수를 최소화하기 위해 반복해서 파라미터를 조정해가는 겁니다.

산속에서 길을 잃고, 시야도 없는 경우에는 어떻게 해야 할까요? 발로 지면의 기울기를 느낄 수 있으므로 가장 쉬운 방법은 가파른 길을 따라 아래로 내려가는 것입니다. 이것이 경사 하강법의 원리입니다.

경사 하강법에서 중요한 파라미터는 스텝의 크기로, 학습률 하이퍼파라미터로 결정됩니다. 학습률이 너무 작으면 알고리즘이 수렴하기 위해 반복을 많이 진행해야 하므로 시간이 오래 걸립니다. 한편, 학습률이 너무 크면 알고리즘을 더 큰 값으로 발산하게 만들어 적절한 해법을 찾지 못하게 합니다.

매끈한 그릇과 같지 않은 비용 함수에서 경사 하강법의 문제점을 찾아볼 수 있습니다.

• 전역 최솟값에 도달하지 않고 지역 최솟값에 수렴하게 되는 경우
• 전역 최솟값에 도달하지 못하고 평탄한 지역에 머무르게 되는 경우

특성 스케일링 유무에 따라 비용 함수의 모양이 결정될 수 있습니다. 특성 스케일링을 하면 그릇 모양이 될 것이고, 하지 않으면 상대적으로 길쭉한 모양이 될 수도 있습니다.

배치 경사 하강법

경사 하강법을 구현하려면 각 모델 파라미터 $\theta_j$에 대해 비용 함수의 그레디언트를 계산해야 합니다. 이를 편도함수라고 합니다. 이는 ‘동쪽을 바라봤을 때 발밑에 느껴지는 산의 기울기는 얼마인가?’와 같은 질문입니다. 그리고 같은 질문을 다른 방향(다른 특성)에 대해서도 합니다. 파라미터 $\theta_j$에 대한 비용함수의 편도함수는 다음과 같습니다.

편도함수를 각각 계산하는 대신 다음과 같이 한꺼번에 계산할 수 있습니다. 그레디언트 벡터 $\nabla_{\theta} * MSE(\theta)$는 비용 함수의 편도함수를 모두 담고 있습니다.

이 공식은 매 경사 하강법 스텝에서 전체 훈련 세트 $X$에 대해 계산합니다. 그래서 이 알고리즘을 배치 경사 하강법이라고 합니다. 매 스텝에서 훈련 데이터 전체를 사용하므로 매우 큰 훈련 데이터셋에서는 아주 느립니다. 그러나 경사 하강법은 특성 수에 민감하지 않으므로, 매우 많은 특성에서 선형 회귀를 훈련시키려면 정규방정식이나 SVD 분해보다 경사 하강법을 사용하는 편이 훨씬 빠릅니다.

경사 하강법의 스텝의 최종적인 식은 다음과 같습니다.

이 알고리즘을 구현해봅시다.

eta = 0.1
            n_iterations = 1000
            m = 100

            theta = np.random.randn(2, 1)

            for iteration in range(n_iterations):
                gradients = 2/m * X_b.T.dot(X_b.dot(theta) - y)
                theta = theta - eta * gradients

            theta

정규방정식으로 찾은 것과 정확히 같습니다. 적절한 학습률을 찾는 것도 중요한데 이를 위해서는 그리드 탐색을 사용합니다. 하지만, 그리드 탐색에서 수렴하는 데 너무 오래 걸리는 모델을 막기 위해 반복 횟수를 제한해야 합니다.

반복 횟수가 너무 작은면 최적점에 도달하기 전에 알고리즘이 멈출 것이고, 너무 크면 모델 파라미터가 더는 변하지 않는 동안 시간을 낭비하게 됩니다. 간단한 해결책은 반복 횟수를 아주 크게 지정하고 그레디언트 벡터가 아주 작아지면 즉, 벡터의 노름이 어떤 값 epsilon(허용오차)보다 작아지면 경사하강법이 거의 최솟값에 도달한 것이므로 알고리즘을 중지하는 것입니다.

확률적 경사 하강법

배치 경사 하강법은 전체 훈련 세트를 사용해 그레디언트를 계산하기 때문에 매우 큰 훈련 세트에서는 아주 느립니다. 확률적 경사 하강법은 이와는 정반대입니다.

확률적 경사 하강법은 매 스텝에서 한 개의 샘플을 무작위로 선택하고 그 하나의 샘플에 대한 그레디언트를 계산합니다. 이는 확실히 배치 경사 하강법보다 훨씬 빠르고, 매우 큰 훈련 세트도 훈련시킬 수 있습니다.

반면, 확률적이므로 이 알고리즘은 배치 경사 하강법보다 훨씬 불안정합니다.

비용 함수가 최솟값에 다다를 때까지 부드럽게 감소하지 않고 요동치며 평균적으로 감소합니다.

이러한 무작위성은 양날의 검입니다.

지역 최솟값을 건너뛰도록 도와주는 동시에, 전역 최솟값에 다다르지 못하게 합니다. 이 딜레마를 해결하는 한 가지 방법은 학습률을 점진적으로 감소시키는 것입니다. 매 반복에서 학습률을 결정하는 함수를 학습 스케줄이라고 부릅니다.

학습 스케줄을 사용한 확률적 경사 하강법을 구현해봅시다.

n_epochs = 50
            t0, t1 = 5, 50

            def learning_schedule(t):
                return t0 / (t + t1)

            theta = np.random.randn(2, 1)

            for epoch in range(n_epochs):
                for i in range(m):
                    random_index = np.random.randint(m)
                    xi = X_b[random_index:random_index+1]
                    yi = y[random_index:random_index+1]
                    gradients = 2 * xi.T.dot(xi.dot(theta) - yi)
                    eta = learning_schedule(epoch * m + i)
                    theta = theta - eta * gradients

            theta

확률적 경사 하강법을 사용할 때 훈련 샘플이 IID(Independent and Identically Distributed)를 만족해야 평균적으로 파라미터가 전역 최적점을 향해 진행한다고 보장할 수 있습니다. 이렇게 만드는 간단한 방법은 훈련하는 동안 샘플을 섞는 것입니다.

사이킷런에서 SGD 방식으로 선형 회귀를 사용하려면 기본값으로 제곱 오차 비용 함수를 최적화하는 SGDRegressor 클래스를 사용합니다.

from sklearn.linear_model import SGDRegressor

            sgd_reg = SGDRegressor(max_iter=1000, tol=1e-3, penalty=None, eta0=0.1)
            sgd_reg.fit(X, y.ravel())
            sgd_reg.intercept_, sgd_reg.coef_

미니배치 경사 하강법

각 스텝에서 미니배치라 부르는 임의의 작은 샘플 세트에 대해 그레디언트를 계산합니다. 주요 장점은 행렬 연산에 최적화된 하드웨어, 특히 GPU를 사용해서 얻는 성능 향상입니다.

미니배치를 어느 정도 크게 하면 이 알고리즘은 파라미터 공간에서 SGD보다 덜 불규칙하게 움직입니다. 무작위성이 줄어들어 SGD보다 최솟값에 더 가까이 도달하게 될 겁니다. 하지만 선형 회귀와 같지 않고 최솟값이 문제가 되는 경우 지역 최솟값에서 빠져나오기는 더 힘들 수도 있습니다.

정규방정식, SVD, BGD, SGD, MGD를 선형 회귀를 사용해 비교하면 다음과 같습니다. m은 훈련 샘플 수이고, n은 특성 수입니다.

알고리즘	m이 클 때	외부 메모리 학습 지원	n이 클 때	하이퍼파라미터 수	스케일 조정 필요	사이킷런
정규방정식	빠름	No	느림	0	No	N/A
SVD	빠름	No	느림	0	No	LinearRegression
BGD	느림	No	빠름	2	Yes	SGDRegressor
SGD	빠름	Yes	빠름	≥ 2	Yes	SGDRegressor
MGD	빠름	Yes	빠름	≥ 2	Yes	SGDRegressor

이 알고리즘들은 훈련 결과에 거의 차이가 없습니다. 모두 매우 비슷한 모델을 만들고 정확히 같은 방식으로 예측을 합니다.

다항 회귀

이제는 가지고 있는 데이터가 단순한 직선이 아닌 복잡한 형태일 때를 두고 얘기해볼 겁니다. 놀랍게도 비선형 데이터를 학습하는 데 선형 모델을 사용할 수 있습니다. 각 특성의 거듭제곱을 새로운 특성으로 추가하고, 이 확장된 특성을 포함한 데이터셋에 선형 모델을 훈련시키는 겁니다. 이 기법을 다항 회귀라고 합니다.

간단한 2차방정식으로 비선형 데이터를 생성하겠습니다.

m = 100
            X = 6 * np.random.rand(m, 1) - 3
            y = 0.5 * X**2 + X + 2 + np.random.randn(m, 1)

plt.plot(X, y, "b.")
            plt.xlabel("$x_1$", fontsize=18)
            plt.ylabel("$y$", rotation=0, fontsize=18)
            plt.axis([-3, 3, 0, 10])
            plt.show()

사이킷런의 PolynomialFeatures를 사용해 훈련 데이터를 변환해봅시다. 이는 훈련 세트에 있는 각 특성을 제곱하여 새로운 특성으로 추가합니다.

from sklearn.preprocessing import PolynomialFeatures

            poly_features = PolynomialFeatures(degree=2, include_bias=False)
            X_poly = poly_features.fit_transform(X)
            print(X[0])
            print(X_poly[0])

$X_{poly}$는 원래 특성 $X$와 이 특성의 제곱을 포함합니다. 이 확장된 훈련 데이터에 LinearRegression을 적용해보겠습니다.

lin_reg = LinearRegression()
            lin_reg.fit(X_poly, y)
            lin_reg.intercept_, lin_reg.coef_

예측 모델이 원함수에 근접합니다. 이를 그려보면 다음과 같습니다.

X_new=np.linspace(-3, 3, 100).reshape(100, 1)
            X_new_poly = poly_features.transform(X_new)
            y_new = lin_reg.predict(X_new_poly)
            plt.plot(X, y, "b.")
            plt.plot(X_new, y_new, "r-", linewidth=2, label="Predictions")
            plt.xlabel("$x_1$", fontsize=18)
            plt.ylabel("$y$", rotation=0, fontsize=18)
            plt.legend(loc="upper left", fontsize=14)
            plt.axis([-3, 3, 0, 10])
            plt.show()

특성 사이의 관계

특성이 여러 개일 때 다항 회귀는 이 특성 사이의 관계를 찾을 수 있습니다. PolynomialFeatures는 주어진 차수까지 특성 간의 모든 교차항을 추가합니다. 예를 들어, 두 개의 특성 $a$, $b$가 있을 때 $degree$가 3이라면 $a^2$, $a^3$, $b^2$, $b^3$뿐만 아니라 $ab$, $a^{2b}$, $ab^2$도 특성으로 추가합니다. 특성 수가 교차항을 포함해 엄청나게 늘어날 수 있으니 사용에 주의해야 합니다.

학습 곡선

당연한 얘기지만, 고차 다항 회귀를 적용하면 선형 회귀에서보다 훨씬 더 훈련 데이터에 잘 맞추려 할 겁니다. 선형 모델, 2차 모델, 300차 다항 회귀 모델을 이전의 훈련 데이터에 적용해 결과를 비교해봅시다.

from sklearn.preprocessing import StandardScaler
            from sklearn.pipeline import Pipeline

            for style, width, degree in (("g-", 1, 300), ("b--", 2, 2), ("r-+", 2, 1)):
                polybig_features = PolynomialFeatures(degree=degree, include_bias=False)
                std_scaler = StandardScaler()
                lin_reg = LinearRegression()
                polynomial_regression = Pipeline([
                        ("poly_features", polybig_features),
                        ("std_scaler", std_scaler),
                        ("lin_reg", lin_reg),
                    ])
                polynomial_regression.fit(X, y)
                y_newbig = polynomial_regression.predict(X_new)
                plt.plot(X_new, y_newbig, style, label=str(degree), linewidth=width)

            plt.plot(X, y, "b.", linewidth=3)
            plt.legend(loc="upper left")
            plt.xlabel("$x_1$", fontsize=18)
            plt.ylabel("$y$", rotation=0, fontsize=18)
            plt.axis([-3, 3, 0, 10])
            plt.show()

고차 다항 회귀 모델은 심각하게 훈련 데이터에 과대적합된 반면, 선형 모델은 과소적합되었습니다. 이 중 가장 일반화가 잘 된 모델은 2차 다항 회귀입니다. 2차 함수로 생성한 데이터이기 때문에 당연한 결과이겠죠. 하지만 일반적으로는 어떤 함수로 데이터가 생성됐는지 알 수 없습니다. 그러면 얼마나 복잡한 모델을 사용해야 하며, 모델이 데이터에 과대적합 또는 과소적합되었는지 어떻게 알 수 있을까요?

2장에서 모델의 일반화 성능 추정을 위해 교차 검증을 사용하여 모델의 과대적합 및 과소적합을 확인했습니다. 또 다른 방법은 학습 곡선을 살펴보는 겁니다.

학습 곡선은 훈련 세트와 검증 세트의 모델 성능을 훈련 세트 크기의 함수로 나타냅니다.

이 그래프를 생성하기 위해서는 단순히 훈련 세트에서 크기가 다른 서브 세트를 만들어 모델을 여러 번 훈련시키면 됩니다.

from sklearn.metrics import mean_squared_error
            from sklearn.model_selection import train_test_split

            def plot_learning_curves(model, X, y):
                X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=10)
                train_errors, val_errors = [], []
                for m in range(1, len(X_train)):
                    model.fit(X_train[:m], y_train[:m])
                    y_train_predict = model.predict(X_train[:m])
                    y_val_predict = model.predict(X_val)
                    train_errors.append(mean_squared_error(y_train[:m], y_train_predict))
                    val_errors.append(mean_squared_error(y_val, y_val_predict))

                plt.plot(np.sqrt(train_errors), "r-+", linewidth=2, label="훈련 세트")
                plt.plot(np.sqrt(val_errors), "b-", linewidth=3, label="검증 세트")

lin_reg = LinearRegression()
            plot_learning_curves(lin_reg, X, y)

훈련 세트에 1~2개의 샘플이 있을 땐 모델이 완벽하게 작동하지만, 훈련 세트에 샘플이 추가됨에 따라 잡음도 있고 비선형이기 때문에 모델이 훈련 데이터를 완벽히 학습하는 것이 불가능해집니다.

검증 데이터에서는 모델이 적은 수의 훈련 샘플로 훈련될 때는 제대로 일반화할 수 없어서 검증 오차가 초기에 매우 크지만 모델에 훈련 샘플이 추가됨에 따라 학습이 되고 검증 오차가 천천히 감소합니다. 하지만, 선형 회귀의 직선은 데이터를 잘 모델링할 수 없으므로 오차의 감소가 완만해져서 훈련 세트의 그래프와 가까워집니다.

두 곡선이 수평한 구간을 만들고 꽤 높은 오차에서 매우 가까이 근접해있으므로 이 학습 곡선은 모델의 과소적합을 나타냅니다. 이 때에는 훈련 샘플을 더 추가해도 효과가 없으므로 더 복잡한 모델을 사용하거나 더 나은 특성을 사용해야 합니다.

같은 데이터에서 10차 다항 회귀 모델의 학습 곡선을 그려봅시다.

from sklearn.pipeline import Pipeline

            polynomial_regression = Pipeline([
                ("poly_features", PolynomialFeatures(degree=10, include_bias=False)),
                ("lin_reg", LinearRegression()),
            ])

            plot_learning_curves(polynomial_regression, X, y)
            plt.axis([0, 80, 0, 3])
            plt.show()

다음과 같이 이전 학습 곡선과 두 가지 중요한 차이점이 있습니다.

• 훈련 데이터의 오차가 선형 회귀 모델보다 훨씬 낮음
• 두 곡선 사이에 공간이 있음
  • 훈련 데이터에서의 성능이 검증 데이터에서보다 훨씬 좋음
  • 과대적합 모델의 특징
  • 더 큰 훈련 세트를 사용하면 모델의 성능 개선 가능

편향/분산 트레이드오프

모델의 일반화 오차는 다음과 같이 세 가지 다른 종류의 오차의 합으로 표현할 수 있습니다.

• 편향
  • 잘못된 가정으로 인해 발생
  • ex. 데이터가 실제로는 2차인데 선형으로 가정하는 경우
  • 편향이 큰 모델은 훈련 데이터에 과소적합되기 쉬움
• 분산
  • 훈련 데이터에 있는 작은 변동에 모델이 과도하게 민감하기 때문에 발생
  • 자유도가 높은 모델이 높은 분산을 가지기 쉬워 훈련 데이터에 과대적합되는 경향 존재
• 줄일 수 없는 오차
  • 데이터 자체에 있는 잡음 때문에 발생
  • 오차를 줄이기 위해 데이터에서 잡음을 제거

모델의 복잡도가 커지면 통상적으로 분산이 늘어나고, 편향을 줄어듭니다. 반대로 모델의 복잡도가 줄어들면 편향이 커지고 분산이 작아집니다. 그래서 이를 편향/분산 트레이드오프라고 합니다.

규제가 있는 선형 모델

앞서 1장과 2장에서 보았듯이 과대적합을 감소시키는 방법으로 모델 규제가 있었습니다. 다항 회귀 모델을 규제하기 위해서는 다항식의 차수를 감소시키면 됩니다.

선형 회귀 모델에서는 보통 모델의 가중치를 제한함으로써 규제를 가합니다. 각기 다른 방법으로 가중치를 제한하는 릿지 회귀, 라쏘 회귀, 엘라스틱넷을 살펴보겠습니다.

릿지 회귀

릿지 회귀는 규제가 추가된 선형 회귀입니다.

다음과 같은 규제항이 비용 함수에 추가됩니다.

이는 학습 알고리즘을 데이터에 맞추는 것뿐만 아니라 모델이 가중치가 가능한 한 작게 유지되도록 노력합니다. 규제항은 훈련하는 동안에만 비용 함수에 추가됩니다. 모델의 훈련이 끝나면 성능을 규제가 없는 성능 지표로 평가합니다.

일반적으로 훈련하는 동안 사용되는 비용 함수와 테스트에서 사용되는 성능 지표는 다릅니다. 훈련에 사용되는 비용 함수는 최적화를 위해 미분 가능해야 하는 반면, 테스트에 사용되는 성능 지표는 최종 목표에 가능한 가까워야 하기 때문입니다.

하이퍼파라미터 alpha는 모델이 얼마나 많이 규제할지 조절합니다. alpha가 0이면 규제를 가하지 않으므로 릿지 회귀는 선형 회귀와 같아집니다. alpha가 아주 크면 모든 가중치가 거의 0에 가까워지고 결국 데이터의 평균을 지나는 수평선이 됩니다.