2018/11/25 - [Study/인공지능학습] - [머신러닝 reboot] 개념 잡기 : 경사 하강법 1 - 특성의 scale
2018/12/10 - [Study/인공지능학습] - [머신러닝 reboot] 개념 잡기 : 경사 하강법 2 - step 공식 이해하기
머신러닝 Reboot - 개념 잡기 : 경사 하강법 3 - 경사 하강법의 종류
지난 포스팅에서 경사 하강법의 특성 스케일과 스텝에 대해서 알아보았다.
여전히 이해도가 낮은데다가 너무 세세한 부분까지 이해하려고 하다보니 진도가 잘 안나간다.
그렇다고 뭔가를 확실히 알게된 것도 아니고…ㅠ.ㅠ 그저 ‘아~ 그래서 이럴 것 같다…’라는 느낌적인 느낌을
갖게 된 것 정도가 소득이라면 소득일까…
아직은 계란으로 바위치는 기분이지만 그래도 학습의 끈을 놓을 수는 없다.
그래서 오늘도 정리는 계속된다~
오늘은 경사 하강법의 종류에 대해 정리해보도록 하자.
이 포스팅에 사용된 코드는 모두 핸즈온 머신러닝(오렐리앙 제롱 저, 박해선 역, 한빛미디어 출판)에서
가져왔거나 일부 수정한 코드입니다.
경사 하강법 복습
경사 하강법이란 비용 함수를 최소화 할 수 있는 가중치(𝜭)를 찾아가는 과정으로 그 방법은 비용 함수를 가중치(𝜭)에
대해 미분하고 이 결과가 작아지는 방향으로 반복해서 진행을 하는 것이다. 이 때 매 반복이 각 단계 사이에 얼마만큼의
거리를 둘 것인지 하는 학습률이 매우 중요한데 학습률이 너무 높으면 중구난방 발산을 하게 되고 반대로 너무
낮으면 시간이 오래 걸려 최솟값에 도달하지 못할 수 있다.
경사 하강법은 매우 일반적이고 단순한 알고리즘이지만 함수의 그래프가 단 한개의 오목한 점을 가질 때(convex)만
잘 작동을 한다. 함수의 그래프에 오복한 부분이 많은 경우(non-convex) 초기화가 어떻게 되느냐에 따라 지역
최솟값에서 멈출 수 있다.
또한 지난 포스팅에서 본 것처럼 특성의 스케일에 민감하여 2개 이상의 특성이 있을 때 각
특성간의 스케일이 크게 차이가 나면 최솟값에 도달하는데 오랜 시간이 걸리게 된다.
참고 : 특성의 스케일 (https://mazdah.tistory.com/833)
선형 회귀의 경우 비용함수의 그래프는 전역 최솟값 하나만 존재하는 그래프이기 때문에 경사 하강법은 좋은 방법이
될 수 있으며 특성의 스케일만 적절하게 조정을 해주면 될 것이다.
이러한 경사 하강법은 훈련세트의 범위를 어떻게 지정하여 계산하느냐에 따라 배치 경사 하강법, 확률적 경사 하강법,
미니 배치 경사 하강법으로 나누어 볼 수 있다.
배치 경사 하강법
배치 경사 하강법은 매 스텝에서 전체 훈련 데이터를 사용하여 계산을 한다. 따라서 매우 큰 훈련 세트에서는 성능이
떨어지게 된다.
배치 경사 하강법에 대해서는 이전 포스팅에서 상세하게 다루었으므로 아래 링크를 참조하기 바란다.
참고 : 배치 경사 하강법의 STEP (http://mazdah.tistory.com/834)
아래는 핸즈온 머신러닝(이하 책)에 실린 예제 코드이다. 그래프 그리는 부분을 약간 수정했다. 라이브러리 import와
데이터 생성 부분은 책을 참조하시기 바란다.
# 다른 경사 하강법과의 비교를 위해 theta값을 저장할 배열
theta_path_bgd = []
eta = 0.1 # 학습률
n_iterations = 1000 # 반복 횟수
m = 100 # 샘플 수
theta = np.random.randn(2, 1) # theta 초기화
for iteration in range(n_iterations):
gradient = 2/m * X_b.T.dot(X_b.dot(theta) - y)
theta = theta - eta * gradient
theta_path_bgd.append(theta)
# 처음 10번의 step에 대한 그래프와 마지막 step의 그래프를 그리기 위한 코드
if iteration <= 10 or iteration == 999:
X_new = np.array([[0], [2]])
X_new_b = np.c_[np.ones((2, 1)), X_new]
y_predict = X_new_b.dot(theta)
y_predict
style = "g--"
if iteration == 999:
style = "r-"
plt.plot(X_new, y_predict, style)
plt.plot(X, y, "b.")
plt.axis([0,2,0,15])
plt.show()
theta
##########################################################
# API 설명 #
##########################################################
# np.ones((2,1))는 파라미터로 전달된 shape의 배열을 1로 채운다. (기본 데이터 타입은 실수로 1.으로 채워진다.)
# np.c_는 파라미터로 전달된 2개의 배열에 대해 동일행의 요소를 배열로 합친 (첫 번째 파라미터의 요소는 0열, 두 번째 파라미터의 요소는 1열) 새로운 배열을 만든다.
# 예)
# >>> np.c_[[np.array([1,2,3]), np.array([4,5,6])]]
# array([[1, 4],
# [2, 5],
# [3, 6]])
# >>> np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
# array([[1, 2, 3, 0, 0, 4, 5, 6]])
책에는 처음 10번의 예측 그래프만을 그리고 있으나 배치 경사 하강법 마지막에 설명한 반복 횟수에 대한 설명을 확인
해보고자 마지박 반복 그래프를 하나 더 추가하였다. 처음 10번의 그래프는 초록색 대시로, 마지막 그래프는 빨간 실선
으로 표시했다.
배치 경사 하강법
그래프를 보면 알 수 있듯이 10번째 step의 그래프와 마지막 step의 그래프 사이에는 큰 차이가 없다. 결국 990번은
큰 의미가 없는 step이었다는 뜻인데, 이는 책에서 언급한 바와 같이 반복 횟수의 지정 또한 중요하다는 것을 의미한다.
확률적 경사 하강법
확률적 경사 하강법은 배치 경사 하강법이 훈련 세트가 커짐에 따라 느려지는 단점을 보완한다.
확률적 경사 하강법은 매 스텝에서 무작위로 선택한 한 개의 샘플에 대해서만 그래디언트를 계산하므로 속도가 빠를 뿐만
아니라 메모리 사용에 있어서도 효율이 좋아 매우 큰 훈련 세트도 적용 가능하다. 또한 불규칙성이 지역 최솟값을 건너
뛰게 하여 전역 최솟값을 찾을 가능성을 높여주는 것도 장점으로 볼 수 있다.
다만 최적값에 도달하는 과정이 배치 경사 하강법에 비해 불안정한 것이 단점이다. 또한 최적값에 근접은 하겠지만
말 그대로의 최적값은 얻기 힘들다. 이러한 단점을 해결하는 방법으로 학습률을 조정하는 방법이 있다. 처음에는 학습률을
크게 했다가 점차 학습률을 줄여나가는 방법으로 이 때 학습률을 조정하는 함수를 학습 스케쥴(learning schedule)이라
부른다.
이렇게 확률적 경사 하강법에서는 학습률자체의 크고 작음 뿐만 아니라 학습률을 줄여나가는 속도 역시 중요한 하이퍼
파라미터가 된다. 너무 빨리 줄여나가면 최솟값에 도달하지 못하고 너무 천천히 줄여나가면 시간이 오래 걸리거나 지역
최솟값에 머물 수 있다.
또다른 특징(단점)으로는 훈련세트를 한 번 도는 동안(1 epoch) 여러번 선택되는 샘플과 한 번도 선택되지 않는 샘플이
존재할 수 있는데 이를 방지하기 위해 매 epoch에서 훈련 세트를 섞는 작업을 추가할 수 있다. 다만 이렇게 하면 속도가
느려지게 된다.
# 다른 경사 하강법과의 비교를 위해 theta값을 저장할 배열
theta_path_sgd = []
# 확률적 경사 하강법
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):
# epoch : 훈련세트 전체가 한 차례 반복 되는 단위. 50번 반복될 동안 전체 샘플 m만큼
# 반복되므로 50 epoch를 실행한다.
for i in range(m):
# 첫 번째 epoch에서 처음 20개의 샘플에 대한 그래프와 최종 그래프를 그림.
if (epoch == 0 and i < 20) or (epoch == 49 and i == 99):
y_predict = X_new_b.dot(theta)
# 처음 그래프는 초록색 대시로, 나머지 그래프는 파란색 실선으로, 마지막 그래프는
# 빨간색 실선으로 표시한다.
style = ""
if epoch == 0 and i > 0:
style = "b-"
elif epoch == 0 and i == 0:
style = "g--"
elif epoch == 49 and i == 99:
style = "r-"
plt.plot(X_new, y_predict, style)
# 0부터 99(m은 100개) 중에 하나를 랜덤하게 가져옴
random_index = np.random.randint(m)
# 무작위로 선택된 인덱스를 확인해보자. 특정 인덱스는 중복해서 사용되고 또 다른 인덱스는
# 사용되지 않는다.
if epoch == 0:
print("random_index = ", random_index)
# 훈련세트와 실제값의 배열에서 랜덤하게 가져온 인덱스 위치의 값 1개씩만 가져온 후
# gradient를 계산한다.
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)
# print("eta : ", eta)
theta = theta - eta * gradients
theta_path_sgd.append(theta)
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()
##########################################################
# API 설명 #
##########################################################
#
# Numpy random
#
# - randn(d0, d1, ..., dn) : 표준 정규분포를 따르는 무작위 실수를 파라미터로 전달받 차수의 배열에
# 채워 리턴한다. 파라미터가 없는 경우 한 개의 실수만 리턴한다.
# 예)
# >>> theta = np.random.randn(2,1)
# >>> theta
# array([[ 0.44730268],
# [-0.04431121]])
#
# - randint(low, high=None, size=None, dtype='l') : 무작위 정수를 리턴한다. low 파라미터는
# 필수로 low 파라미터만 있는 경우에는 0부터 low-1까지의 범위에서 무작위 정수가 리턴되며
# low와 high가 전달되는 경우 low부터 high-1까지의 범위에서 무작위 정수가 리턴된다.
# size가 주어질 경우 size에 해당하는 배열 형태로 리턴된다.
# 예)
# >>> rival = np.random.randint(2)
# >>> rival
# 1 (0또는 1이 무작위로 출력됨)
# >>> rival = np.random.randint(2, 5)
# >>> rival
# 1 (2 ~ 4 사이의 정수가 무작위로 출력됨)
# >>> rival = np.random.randint(2,5, (2,3))
# >>> rival
# array([[3, 3, 4], (2 ~ 4 사이의 정수가 2행 3열의 배열에 무작위로 할당되어 출력됨)
# [3, 2, 3]])
확률적 경사 하강법
동일한 내용을 Scikt Learn으로는 다음과 같이 구현 가능하다.
from sklearn.linear_model import SGDRegressor
# epoch는 50, 초기 학습률은 0.1로 학습한다.
sgd_reg = SGDRegressor(max_iter=50, penalty=None, eta0=0.1)
sgd_reg.fit(X, y.ravel())
# 결과값 보기 : intercept_ = 편향, coef_ = 가중치
sgd_reg.intercept_, sgd_reg.coef_
##########################################################
# API 설명 #
##########################################################
#
# Scikit-learn
#
# - SGDRegressor (loss=’squared_loss’, penalty=’l2’, alpha=0.0001, l1_ratio=0.15,
# fit_intercept=True, max_iter=None, tol=None, shuffle=True,
# verbose=0, epsilon=0.1, random_state=None,
# learning_rate=’invscaling’, eta0=0.01, power_t=0.25,
# warm_start=False, average=False, n_iter=None)
# . 확률적 경사 하강법을 수행하는 클래스로 linear_model 모듈에 포함되어있다.
# . 파라미터 (상당히 많은 파라미터가 있는데 예제에 명시한 파라미터만 간단히 알아보자)
# : max_iter - 전체 훈련 데이터의 반복 횟수(epoch 수)를 지정한다.
# : penalty - 정규화 식. 여기서는 사용하지 않음. l2, l1, elasticnet 등을 사용할 수
# 있다.
# : eta0 - 학습률의 초깃값. API상에 learning_rate라는 파라미터는 학습 스케쥴을 뜻한다.
# 기본값인 ‘invscaling’는 eta = eta0 / pow(t, power_t) 공식에 따라
# 학습률을 조정한다. (자세한 내용은 핸즈온 머신러닝 171쪽 하단의 역주 참조)
미니배치 경사 하강법
미니배치 경사 하강법은 한 epoch에서 미니배치라는 임의의 샘플 세트만으로 계산을 진행하는 것으로 확률적 경사
하강법이 1개의 샘플만 사용하여 계산하는 것과 비교된다. 한편으로는 확률적 경사 하강법은 미니배치의 크기가 1인
미니배치 경사 하강법으로 볼 수도 있다.
이러한 미니배치 경사 하강법은 확률적 경사 하강법에 비해 안정적으로 최솟값에 접근하지만 지역 최솟값을 벗어나기는
더 힘들다.
장점으로는 행렬 연산에 최적화 되어있으며 GPU를 통해 큰 성능 향상을 얻을 수 있다.
# 다른 경사 하강법과의 비교를 위해 theta값을 저장할 배열
theta_path_mgd = []
n_iterations = 50
# 미니배치 크기를 20으로 주었다.
# 이 크기를 1로 주면 확률적 경사 하강법과 동일한 형태의 그래프를 볼 수 있다.
minibatch_size =20
np.random.seed(42)
theta = np.random.randn(2,1) # 무작위 초기화
t0, t1 = 200, 1000
def learning_schedule(t):
return t0 / (t + t1)
t = 0
for epoch in range(n_iterations):
# 인자로 전달된 벡터 또는 행렬 요소의 순서를 무작위로 바꿈.
# 행렬의 경우 첫 번째 인덱스의 순서만 바꾼다.
# 매 epoch마다 순서를 뒤섞어 훈련 세트를 고르게 사용하도록 한다.
shuffled_indices = np.random.permutation(m)
X_b_shuffled = X_b[shuffled_indices]
y_shuffled = y[shuffled_indices]
# minibatch_size만큼 샘플을 뽑아 계산하므로 for문에서도 minibatch_size만큼씩
# 증가시킨다.
for i in range(0, m, minibatch_size):
#print(epoch , " : ", i)
# 그래프 그리기. minibatch_size가 20이므로 한 epoch에서 5번만에 연산이 끝난다.
# 따라서 2 epoch가 진행될 동안 총 10개의 그래프가 그려진다.
if epoch < 2 and i < 100:
y_predict = X_new_b.dot(theta)
style = "b-" if i > 0 else "r--"
plt.plot(X_new, y_predict, style)
t += 1
# 매 epoch마다 뒤섞은 훈련 세트에서 minibatch_size만큼의 샘플만을 가져와서
# gradient를 계산한다.
xi = X_b_shuffled[i:i+minibatch_size]
yi = y_shuffled[i:i+minibatch_size]
gradients = 2/minibatch_size * xi.T.dot(xi.dot(theta) - yi)
eta = learning_schedule(t)
theta = theta - eta * gradients
theta_path_mgd.append(theta)
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()
##########################################################
# API 설명 #
##########################################################
#
# Numpy random
#
# - permutation(x) : 파라미터로 주어진 배열의 순서를 무작위로 바꾸어 출력한다.
# 예)
# >>> x = np.random.permutation([1,2,3,4,5,6,7,8,9,10])
# >>> x
# array([ 7, 2, 1, 4, 3, 8, 9, 5, 10, 6])
 미니배치 크기 20 |  미니배치 크기 1 |
위의 그래프를 보면 확률적 경사 하강법의 그래프보다 미니배치 경사 하강법에서 미니배치를 1로 준 그래프가 좀 더
발산이 심한데 이는 아마도 하이퍼파라미터가 달라서 발생하는 현상일 것이다.
비교
마지막으로 3개의 경사하강법을 실행하면서 저장한 theta값의 배열을 기반으로 그래프를 그려보면 아래와 같다.
배치 경사 하강법이 곧장 최솟값으로 향한 반면 확률적 경사 하강법과 미니배치 경사 하강법은 최솟값 부근에서 매우
불안정하게 움직인다. 하지만 앞서 살펴본대로 배치 경사 하강법은 샘플이 많아질수록 느려지고 확률적 경사 하강법과
미니배치 경사 하강법도 적절한 하이퍼파라미터를 사용하면 결국은 최솟값에 도달한다.
마지막으로 각 경사 하강법의 특징을 정리하면 다음과 같다.
배치 경사 하강법 : 샘플 수가 클 때 느림, 특성 수에 상관없이 빠름, 특성 스케일 조정 필요
확률적 경사 하강법 : 샘플 수에 상관없이 빠름, 특성 수에 상관없이 빠름, 특성 스케일 조정 필요
미니배치 경사 하강법 : 샘플 수에 상관없이 빠름, 특성 수에 상관없이 빠름, 특성 스케일 조정 필요
더 상세한 비교 내용은 핸즈온 머신러닝 172쪽을 참고하라
다항 회귀
다항회귀는 데이터가 비선형인 경우(2차 이상의 함수 형태를 띠는 경우) 사용할 수 있는 회귀 분석이다.
다항회귀의 경우 직관적으로 접근하는 것이 좀 더 이해하기가 쉬운데 데이터의 그래프를 보고 적절한 차수를
제곱한 특성을 추가하여 분석하는 것이다.
비선형의 데이터를 선형 회귀 분석으로 계산할 수 있는 이유는 선형의 의미가 가설함수의 독립변수에 대한 것이 아니라
가중치 𝜭에 대한 것이기 때문이다. 즉 𝜭에 대한 1차 식(선형 식)으로 풀어낼 수 있다는 의미인 것이다.
이렇게 봤을 때 결과론적이긴 하지만 아래 코드를 보면 결국 이 예제의 가설함수는 위에 언급한 것과 같이 𝜭를 기준으로
본다면 특성이 2개인 함수일 뿐이다. 다만 기존에는 서로 독립적인 특성들, 즉 x1, x2, x3…xn에 대해 다뤘다면 다항
회귀에서는 x, x^2, x^3…x^n과 같이 하나의 특성 x에 대해 그 거듭제곱들이 특성이 되는 점이 다르다고 할 수있다.
결국 다항회귀는 다중회귀의 특수한 형태라고 볼 수 있는 것이다.
다만 우리가 훈련세트를 받았을 때 특성은 오직 x 하나만 주어지기 때문에 추가적인 특성(x의 거듭제곱)을 어떻게
처리할 것인지에 대해서는 선택이 쉽지 않은데 처음 이야기한 바와 같이 직관에 의존해서 결정을 할 수도 있겠지만
너무 차수가 높은 특성이 추가되는 경우 과대적합에 빠지기 쉬운 문제가 있다. 때문에 보통은 교차 검증을 사용하거나
학습 곡선을 살펴 결정하게 된다.
import numpy as np
import numpy.random as rnd
# 맷플롯립 설정
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
# 각각 차수를 300, 2, 1로 하여 그래프를 그려본다. 튜플의 앞 두 개의 요소는 그래프 스타일이다.
for style, width, degree in (("g-", 1, 300), ("b--", 2, 2), ("r-+", 2, 1)):
# 특성을 추가한다. 300차, 2차, 1차를 적용해본다.
polybig_features = PolynomialFeatures(degree=degree, include_bias=False)
# 표준화 인스턴스를 만든다.
std_scaler = StandardScaler()
# 추정기로 선형 회귀를 사용한다.
lin_reg = LinearRegression()
# 2개의 변환기와 1개의 추정기로 구성된 Pipeline을 만든다.
polynomial_regression = Pipeline([
("poly_features", polybig_features),
("std_scaler", std_scaler),
("lin_reg", lin_reg),
])
# Pipeline 실행
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])
#save_fig("high_degree_polynomials_plot")
plt.show()
##########################################################
# API 설명 #
##########################################################
#
# Scikit-learn
#
# - LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1)
# . linear_model 모듈에 있는 클래스로 최소제곱법을 통한 선형회귀를 수행한다.
# . 파라미터 (모든 파라미터는 기본 값이 있는 optional이다.)
# : fit_intercept - 연산에 편향(bias)를 포함 시킬 것인지를 결정한다.
# : normalize - 특성을 정규화 할 지 여부를 설정한다. fit_intercept가 False이면
# 무시된다.
# : copy_X - True면 특성을 복사하고 False면 특성을 덮어씌운다.
# : n_jobs - 수행할 job의 수로 사용할 CPU의 수라고 생각하면 된다. -1이면 모든 CPU를
# 사용한다.
#
# - PolynomialFeatures(degree=2, interaction_only=False, include_bias=True)
# . 파라미터로 설정된 차수(degree)와 같거나 작은 차수의 모든 다항식 조합을 특성에 추가한다.
# 차수가 2이고 전달된 특성이 [2, 3]라면 [2, 3, 2^2, 2 * 3, 3^2]이 생성된다.
# 이 때 사용되는 특성은 2D 이상의 배열이어야 한다. 즉 [[2, 3]] 형태여야 한다.
# . 파라미터(모든 파라미터는 기본 값이 있는 optional이다.)
# : degree - 다항식의 차수
# : interaction_only - True로 설정되면 제곱수가 포함된 수는 모두 빠지고 원래의 특성
# 값들과 특성들의 곱만 포함된다. 즉 [[2,3]]에 대해 [2, 3, 6]이
# 출력된다.
# : include_bias - 편향을 포함할 것인지를 설정한다.
#
# - Pipeline(steps, memory=None)
# . list 타입으로 전달된 첫 번째 파라미터의 요소들을 순차적으로 실행한다. 이 때 앞 단계의 결과가
# 다음 다계의 입력으로 들어간다. 이 파라미터에는 반드시 변환기가 있어야 하며 변환기는 fit()
# 함수와 transform() 함수가 구현되어 있어야 한다. Pipeline의 마지막에는 추정기가 실행되며
# 추정기는 fit() 함수만 구현되어 있으면 된다.
# * 추정기와 변환기에 대해서는 핸즈온 머신러닝 101쪽의 "사이킷런의 설계 철학"을 참고하라.
# ** Pipeline에 대해서는 핸즈온 머신러닝 108쪽 "2.5.5 변환 파이프라인"을 참조하라
# . 파라미터
# : steps - list 타입이어야 하며 변환기와 추정기가 포함되어있어야 한다. 각 요소는
# 이름/추정기(변환기) 쌍으로 되어있으며 마지막 단계는 추정기나 변환기를 모두
# 사용할 수 있지만 이전 단계는 모두 변환기여야 한다.
# : memory - 변환기의 캐시 사용 여부를 결정한다.
#
# - StandardScaler(copy=True, with_mean=True, with_std=True)
# . 특성의 평균을 뺀 후 표준편차로 나누어 표준화 해주는 클래스. 평균이 0 표준편차가 1인
# 정규분포로 표준화 한다.
# * 자세한 내용은 핸즈온 머신러닝 107쪽 "2.5.4 특성 스케일링" 하단의 표준화를 참조하라.
# . 파라미터
# : copy - 복사본 사용 여부를 결정한다.
# : with_mean - 스케일링 하기 전에 데이터의 중간을 맞춰준다(의미를 잘 모르겠음...ㅠ.ㅠ).
# : with_std - 분산 혹은 표준편차에 맞게 스케일링한다(역시 명확한 의미를 모르겠음...ㅠ.ㅠ).
다항회귀
위 그래프를 보면 데이터의 형태가 아래로 오목한 2차 함수의 형태와 유사하다(물론 책의 전개상 데이터를 생성한
함수가 2차 함수에 노이즈를 추가한 것임을 알고 있으나 실제로는 이 함수를 찾아내는 것이 머신러닝의 역할이다).
따라서 제공된 특성을 제곱한 값으로 특성을 추가한 예측 그래프가 가장 적절해 보인다. 차수를 300으로 올리면
보다 많은 데이터와 일치하게 되지만 너무 훈련 데이터에 과대적합된 형태라 볼 수 있다.
일반적으로 과소적합인 경우에는 더 복잡한 모델을 사용해야 하며, 과대적합인 경우에는 더 많은 훈련 샘플을 추가해야
한다.
정리
가장 기초단계라고 할 수 있는 선형 회귀 이지만 꾸역꾸역 깊이 파고들다보니 역시 수학적인 요소들로 가득 차있다.
현 상황에서야 굳이 각 API들의 세부적인 부분들까지 알 필요 없이 기본적인 사용법만으로 충분하겠으나 실무에
적용하기 위해서는 분명 파라미터들의 의미를 이해하고 자유자재로 사용할 수 있어야 할 것이다.
다만 Scikit Learn의 경우 국내에서는 텐서플로우나 케라스에 밀려 인기가 없는 탓인지 한글로 된 자료 찾기가 쉽지
않았다. 우선은 공식 문서를 이용해 공부를 해야겠으나 우리말로도 못알아듣는 수학적 내용들을 영어로 어찌 이해할 수
있을지…ㅠ.ㅠ 일단 Scikit Learn의 공식 문서를 링크한다.
https://scikit-learn.org/0.19/_downloads/scikit-learn-docs.pdf
선형회귀의 종류에 대해서는 이정도로 정리하고 다음 포스팅에서는 규제가 있는 선형 모델에 대해 간단하게 알아보도록
하겠다.
