3-1 k-최근접 이웃 회귀

학습 목표

• 지도 학습의 한 종류인 회귀 문제를 이해하고 k-최근접 이웃 알고리즘을 사용해 농어의 무게를 예측하는 회귀 문제를 풀어본다.

1) 데이터 준비 및 모델링

📕 데이터 준비

import numpy as np
perch_length = np.array([8.4, 13.7, 15.0, 16.2, 17.4, 18.0, 18.7, 19.0, 19.6, 20.0, 21.0,
       21.0, 21.0, 21.3, 22.0, 22.0, 22.0, 22.0, 22.0, 22.5, 22.5, 22.7,
       23.0, 23.5, 24.0, 24.0, 24.6, 25.0, 25.6, 26.5, 27.3, 27.5, 27.5,
       27.5, 28.0, 28.7, 30.0, 32.8, 34.5, 35.0, 36.5, 36.0, 37.0, 37.0,
       39.0, 39.0, 39.0, 40.0, 40.0, 40.0, 40.0, 42.0, 43.0, 43.0, 43.5,
       44.0])
       
perch_weight = np.array([5.9, 32.0, 40.0, 51.5, 70.0, 100.0, 78.0, 80.0, 85.0, 85.0, 110.0,
       115.0, 125.0, 130.0, 120.0, 120.0, 130.0, 135.0, 110.0, 130.0,
       150.0, 145.0, 150.0, 170.0, 225.0, 145.0, 188.0, 180.0, 197.0,
       218.0, 300.0, 260.0, 265.0, 250.0, 250.0, 300.0, 320.0, 514.0,
       556.0, 840.0, 685.0, 700.0, 700.0, 690.0, 900.0, 650.0, 820.0,
       850.0, 900.0, 1015.0, 820.0, 1100.0, 1000.0, 1100.0, 1000.0,
       1000.0])      

📕 데이터 시각화

import matplotlib.pyplot as plt
plt.figure(figsize=(8,8))
plt.scatter(perch_length, perch_weight, label= 'perch')
plt.xlabel('length')++++++
plt.ylabel('weight')
plt.show();

• 결과이미지
  

📕 모델링

from sklearn.model_selection import train_test_split as tts
train_input, test_input, train_target, test_target = tts(perch_length, perch_weight, random_state=42)

# (42,) -> (42,1) 배열 2차원화
train_input = train_input.reshape(-1,1)
test_input = test_input.reshape(-1,1)
print(train_input.shape, test_input.shape)
▶
(42, 1) (14, 1)

❗ discussion
사이킷 런에서 사용할 train set은 2차원 배열이어야 한다.

2) 모델 정확도 평가

📕 결정 계수($R^2$)

from sklearn.neighbors import KNeighborsRegressor

knr = KNeighborsRegressor()

# k-최근접 이웃 회귀 모델을 훈련합니다
knr.fit(train_input, train_target)

print(knr.score(test_input, test_target))
▶
0.992809406101064

❗ discussion
회귀의 경우에 정확도는 결정계수 $R^2$으로 표현한다. (1에 가까워질수록 정확성↑)

결정계수란?
타깃 = $y_i$, 예측치 = $\hat{y}$, 평균 = $\bar{y}$ 일때,
$R^2 = 1 - \frac{(타깃-예측)^2의 합)} {(타깃-평균)^2의 합)} = 1 - \frac{SSE}{SST} = \frac{SSR}{SST} = \sum\frac{(y_i-\bar{y})^2}{(y_i-\hat{y})^2}$

📕 평균 절댓값 오차

from sklearn.metrics import mean_absolute_error

# test set에 대한 예측
test_prediction = knr.predict(test_input)

# test set에 대한 평균 절댓값 오차
mae = mean_absolute_error(test_target, test_prediction)
print(mae)
▶
19.157142857142862

• 결과
  예측한 값이 평균적으로 19g 정도 타깃값과 다르다.

3) 과대적합 vs 과소적합

# train set 훈련
knr.fit(train_input, train_target)

# train set 평가
print(knr.score(train_input, train_target))
▶
0.9698823289099254

# test set 평가
print(knr.score(test_input, test_target))
▶
0.992809406101064

• 결과
  train set의 평가가 test set의 평가보다 낮게 나왔다.

❗ discussion
보통의 경우 train set으로 훈련하였으므로 train set에 더 잘 맞는 결과가 나올 것이다.

• 만약 train set의 점수가 굉장히 좋았는데 test set의 점수가 굉장히 나쁘다면,
  모델이 train set에 과대적합 되었다고 한다.(train set에만 잘 맞음)

• 반대로 train set보다 test set의 점수가 높거나 두 점수가 모두 너무 낮은 경우를
  모델이 train set에 과소적합 되었다고 한다.

이 모델의 경우에는 train set과 test set의 크기가 매우 작아 과소적합이 일어났다.

이를 해결하기 위해 모델을 조금 더 복잡하게 만들어야 한다.

# 이웃의 개수를 줄여 train set에 있는 국지적인 패턴을 조금 더 따르도록 한다.
knr.n_neighbors = 3

# 모델 재훈련
knr.fit(train_input, train_target)

# train set 평가
print(knr.score(train_input,train_target))
▶
0.9804899950518966

# test set 평가
print(knr.score(test_input,test_target))
▶
0.9746459963987609

• 결과
  train set의 평가가 test set의 평가보다 높게 나왔다.

❗ discussion
test set의 점수가 train set의 점수보다 낮게 나왔으므로 과소적합 문제를 해결하였고,
두 점수의 차이가 크지 않으므로 이 모델이 과대적합된 것 같지도 않다.

4) n_neighbors에 따른 모델 복잡도

📕 n_neighbors 매개변수 차이에 따른 모델 복잡도 변화

knr = KNeighborsRegressor()

x = np.arange(5,45).reshape(-1,1)

for n in [1,5,10] :
    knr.n_neighbors = n
    knr.fit(train_input, train_target)

    prediction = knr.predict(x)

    plt.scatter(train_input, train_target)
    plt.plot(x, prediction)
    plt.title(f'n_neighbors = {n}')
    plt.xlabel('length')
    plt.ylabel('weight')
    plt.show();

• 결과 이미지
  

❗ discussion
n(확인하는 이웃의 수)이 커질수록 모델의 고저가 완만해진다.(모델이 단순해진다.)

📕 키워드 정리

회귀(regression)
분류와 다른 임의의 수치를 예측하는 문제로, 타깃값 또한 임의의 수치가 된다.

k-최근접 이웃 회귀
k- 최근접 이웃 알고리즘을 사용하여 회귀 문제를 푼다.
가장 가까운 이웃 샘플들을 찾고 이 샘플들의 타깃값을 평균하여 예측한다.

결정계수($R^2$)
회귀 문제의 대표적인 성능 측정 도구로 0~1의 값을 가지며 1에 가까울수록 정확한 모델이다.

과대적합
train set의 성능이 test set의 성능보다 훨씬 높을 때 발생한다.
모델이 train set에 너무 집착해서 데이터에 내재된 거시적인 패턴을 감지하지 못하는 경우.

과소적합
train set과 test set 성능이 모두 낮거나 test set의 성능이 오히려 높을 때 발생한다.
더 복잡한 모델을 사용하여 train set에 잘 맞는 모델을 만들어야 한다.

3-2 선형 회귀

학습 목표

• k-최근접 이웃 회귀와 회귀 알고리즘의 차이를 이해하고 사이킷런을 사용해 여러 가지 선형 회귀 모델을 만들어 봅니다.

1) k-최근접 회귀 모델

📕 k - 최근접 모델 생성

import numpy as np
perch_length = np.array([8.4, 13.7, 15.0, 16.2, 17.4, 18.0, 18.7, 19.0, 19.6, 20.0, 21.0,
       21.0, 21.0, 21.3, 22.0, 22.0, 22.0, 22.0, 22.0, 22.5, 22.5, 22.7,
       23.0, 23.5, 24.0, 24.0, 24.6, 25.0, 25.6, 26.5, 27.3, 27.5, 27.5,
       27.5, 28.0, 28.7, 30.0, 32.8, 34.5, 35.0, 36.5, 36.0, 37.0, 37.0,
       39.0, 39.0, 39.0, 40.0, 40.0, 40.0, 40.0, 42.0, 43.0, 43.0, 43.5,
       44.0])
perch_weight = np.array([5.9, 32.0, 40.0, 51.5, 70.0, 100.0, 78.0, 80.0, 85.0, 85.0, 110.0,
       115.0, 125.0, 130.0, 120.0, 120.0, 130.0, 135.0, 110.0, 130.0,
       150.0, 145.0, 150.0, 170.0, 225.0, 145.0, 188.0, 180.0, 197.0,
       218.0, 300.0, 260.0, 265.0, 250.0, 250.0, 300.0, 320.0, 514.0,
       556.0, 840.0, 685.0, 700.0, 700.0, 690.0, 900.0, 650.0, 820.0,
       850.0, 900.0, 1015.0, 820.0, 1100.0, 1000.0, 1100.0, 1000.0,
       1000.0])
       
  from sklearn.model_selection import train_test_split

# train set, test set 구분
train_input, test_input, train_target, test_target = train_test_split(perch_length, perch_weight, random_state=42)

# 2차원 배열 형성
train_input = train_input.reshape(-1,1)
test_input = test_input.reshape(-1,1)

# 최근접 이웃 개수를 3으로 하는 모델 훈련
from sklearn.neighbors import KNeighborsRegressor
knr = KNeighborsRegressor()
knr.n_neighbors = 3

# k-최근접 이웃 회귀 모델 훈련
knr.fit(train_input, train_target)

# 길이 50cm인 농어의 무게 예측
print(knr.predict([[50]]))
▶
1033.33333333

• 결과
  50cm 농어의 무게를 1,033g 정도로 예측하였으나 이는 실제 농어 무게에 비해 훨씬 작ㅇㄴ 값이라고 한다.

📕 scatter plot 확인

• train set과 50cm 농어, 해당 농어의 최근접 이웃을 산점도에 표시

import matplotlib.pyplot as plt

# 50cm 농어의 이웃 구하기
distances, indexes = knr.kneighbors([[50]])

plt.figure(figsize=(8,8))
# train set의 scatter plot
plt.scatter(train_input, train_target, label = 'train set')

# train set 중 이웃 샘플만 다시 그리기
plt.scatter(train_input[indexes], train_target[indexes], marker='D', label = '3 near')

# 50cm 농어 데이터
plt.scatter(50,1033, marker='^', label = '50cm')

plt.xlabel('length')
plt.ylabel('weight')
plt.legend()
plt.show();

• 결과이미지
  

❗ discussion
해당 회귀 모델은 최근접 이웃들의 데이터의 평균으로 예측하는데,
50 cm의 경우 train set의 범위를 넘어가므로, 50cm 이상인 경우 전부 1,033g으로 예측한다.

2) 선형 회귀 모델

선형 회귀란?
널리 사용되는 대표적인 회귀 알고리즘으로,
특성이 하나인 경우 어떤 직선을 학습하는 알고리즘이다.

📕 선형 회귀 모델 생성 및 훈련

from sklearn.linear_model import LinearRegression
lr = LinearRegression()

# 선형 회귀 모델 훈련
lr.fit(train_input, train_target)

# 50cm 농어 예측
print(lr.predict([[50]]))
▶
1241.83860323

# 선형 회귀 모델이 찾은 기울기와 y절편
print(lr.coef_, lr.intercept_)
▶
[39.01714496] -709.0186449535477

❗ discussion
coef_ 속성 이름에서 알 수 있듯이 머신러닝에서 기울기를 계수(coeffcient) 또는 가중치(weight)라고 부른다.
이 두가지 값을 모델 파라미터(model parameter)라고 부른다.
최적의 모델 파라미터를 찾는 학습 과정을 모델 기반 학습이라고 부른다.

📕 선형 회귀 모델 곡선 그리기

plt.figure(figsize=(8,8))
# train set scatter plot
plt.scatter(train_input, train_target, label = 'train set')

# 15에서 50까지 1차 방정식 그래프(직선)을 그린다.
plt.plot([15,50], [15*lr.coef_+lr.intercept_, 50*lr.coef_+lr.intercept_], label = 'linear model')

# 50cm 농어 데이터
plt.scatter(50, 1241.8, marker='^', label = '50cm')

plt.xlabel('length')
plt.ylabel('weight')
plt.legend()
plt.show();

• 결과이미지
  

❗ discussion
scatter plot의 좌측하단 데이터는 곡선에서 많이 벗어난 모습을 보인다.

📕 선형 회귀 모델 $R^2$ 점수 확인

print(lr.score(train_input, train_target))
▶
0.939846333997604

print(lr.score(test_input, test_target))
▶
0.8247503123313558

❗ discussion
train set과 test set의 점수에 조금의 차이가 있다.
train set의 점수도 크게 높지 않기에 전체적으로 과소적합되어있다.

3) 다항 회귀 모델

📕 다항 회귀(2차 곡선) 모델 생성 및 훈련

# train set에 제곱 열을 추가
train_poly = np.column_stack((train_input**2, train_input))
test_poly = np.column_stack((test_input**2, test_input))

print(train_poly.shape, test_poly.shape)
▶
(42, 2) (14, 2)

# 다항 회귀 모델 학습
lr = LinearRegression()
lr.fit(train_poly, train_target)

print(lr.predict([[50**2, 50]]))
▶
[1573.98423528]

# 기울기, y 절편
print(lr.coef_, lr.intercept_)
▶
[  1.01433211 -21.55792498] 116.0502107827827

• 결과
  다항 선형 회귀 모델의 50cm 농어의 무게는 1574g으로 선형 회귀 모델보다 크다.
  해당 모델이 학습한 2차 함수 그래프는 다음과 같다.
  $무게 = 1.01 * 길이^2 - 21.6 * 길이 + 116.05$

❗ discussion
2차 방정식이지만 길이의 제곱을 다른 변수로 치환하면 무게는 길이와 관련된 변수들의 선형관계로 표현할 수 있으므로 2차 방정식도 선형회귀라고 할 수 있다.

📕 다항 회귀(2차 곡선) scatter plot

# 구간별 직선
point = np.arange(15,49)

plt.figure(figsize=(8,8))

# train set
plt.scatter(train_input, train_target, label = 'train set')

# 다항 회귀
plt.plot(point, 1.01*point**2 - 21.6*point + 116.05, marker = '^', label = 'Polynomial Regression')

# 50cm 농어 데이터
plt.scatter(50, 1574, label = '50cm')

plt.xlabel('length')
plt.ylabel('weight')
plt.legend()
plt.show();

• 결과 이미지
  

• 결과
  단순 선형 회귀 모델보다 train set의 경향을 잘 따르고 무게가 음수로 나오지도 않는다.

📕 다항 회귀 모델 $R^2$ 점수 확인

print(lr.score(train_poly, train_target))
▶
0.9706807451768623

print(lr.score(test_poly, test_target))
▶
0.9775935108325122

❗ discussion
train set과 test set의 점수가 모두 크게 올랐지만,
test set의 점수가 조금 더 높은 것으로 보아 과소적합이 아직 남아있다.
이를 해결하기 위해 조금 더 복잡한 모형이 필요할 것이다.

📕 키워드 정리

선형 회귀란
특성과 타깃 사이의 관계를 가장 잘 나타내는 선형방정식을 찾는다.
특성의 개수에 따라 직선 및 곡선의 형태가 정해진다.

다항 회귀란
다항식을 사용하여 특성과 타깃 사이의 관계를 나타낸다.
이 함수는 비선형 일수도 있지만 여전히 선형 회귀로 표현할 수 있다.

모델 파라미터린
선형 회귀가 찾은 가중치처럼 머신러닝 모델이 특성에서 학습한 파라미터를 말합니다.

3-3 특성 공학과 규제

학습 목표

• 여러 특성을 사용한 다중 회귀에 대해 배우고 사이킷런의 여러 도구를 사용해 본다.
  복잡한 모델의 과대적합을 막기 위한 릿지와 라쏘 회귀를 배운다.

1) 다중 회귀(multiple regression)

📕 데이터 준비

import pandas as pd
import numpy as np

# input data(길이, 높이, 두께)
df = pd.read_csv('https://bit.ly/perch_csv_data')
perch_full = df.to_numpy()

# target data(무게)
perch_weight = np.array([5.9, 32.0, 40.0, 51.5, 70.0, 100.0, 78.0, 80.0, 85.0, 85.0, 110.0,
       115.0, 125.0, 130.0, 120.0, 120.0, 130.0, 135.0, 110.0, 130.0,
       150.0, 145.0, 150.0, 170.0, 225.0, 145.0, 188.0, 180.0, 197.0,
       218.0, 300.0, 260.0, 265.0, 250.0, 250.0, 300.0, 320.0, 514.0,
       556.0, 840.0, 685.0, 700.0, 700.0, 690.0, 900.0, 650.0, 820.0,
       850.0, 900.0, 1015.0, 820.0, 1100.0, 1000.0, 1100.0, 1000.0,
       1000.0])

# data set 나누기
from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target = train_test_split(perch_full, perch_weight, random_state=42)

📕 사이킷런의 변환기(transformer)

from sklearn.preprocessing import PolynomialFeatures

# 샘플 확인
poly = PolynomialFeatures()
poly.fit([[2,3]])
print(poly.transform([[2,3]]))
▶
[[1. 2. 3. 4. 6. 9.]]

❗ discussion
fit(훈련)을 해줘야 변환(transform)이 가능하다.
PolynomialFeatures 클래스는 기본적으로 각 특성을 제곱한 항을 추가하고 특성끼리 서로 곱한 항과 1을 추가한다.
사이킷런의 선형 모델은 자동으로 절편을 추가하므로 굳이 1까지 특성에 넣을 필요는 없다.

# 특성에서 1 제거
poly = PolynomialFeatures(include_bias=False)
poly.fit([[2,3]])
print(poly.transform([[2,3]]))
▶
[[2. 3. 4. 6. 9.]]

❗ discussion
include_bias=False로 지정하지 않아도 사이킷런 모델은 자동으로 특성에 추가된 절편 항을 무시한다.

# train set fit & transform
poly = PolynomialFeatures(include_bias=False)
poly.fit(train_input)
train_poly = poly.transform(train_input)
print(train_poly.shape)
▶
(42, 9)

print(poly.get_feature_names_out())
▶
['x0' 'x1' 'x2' 'x0^2' 'x0 x1' 'x0 x2' 'x1^2' 'x1 x2' 'x2^2']

test_poly = poly.transform(test_input)

• 결과
  train set으로 훈련 및 transform을 해주어 9개의 특성이 생겼고,
  train set을 기준으로 test set 또한 transform 해주었다.

📕 다중 회귀 모델 훈련하기

from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(train_poly, train_target)

print(lr.score(train_poly, train_target))
▶
0.9903183436982124

print(lr.score(test_poly, test_target))
▶
0.9714559911594134

• 결과
  농어의 길이, 높이, 두께를 특성으로 모두 사용하였고, 제곱하거나 서로 곱하여 다항 특성으로 추가하였다.
  train set의 점수도 높아질 뿐더러 test set의 점수보다 높아져서 과소적합 문제는 발생하지 않는다.

📕 다중 회귀 모델에 고차원 추가하기

# 모델 특성 5제곱까지 추가하기
poly = PolynomialFeatures(degree=5, include_bias=False)
poly.fit(train_input)
train_poly = poly.transform(train_input)
test_poly = poly.transform(test_input)

print(train_poly.shape)
▶
(42,55)

# train set 훈련
lr.fit(train_poly, train_target)

print(lr.score(train_poly, train_target))
▶
0.9999999999991097

print(lr.score(test_poly, test_target))
▶
-144.40579242684848

• 결과
  train set의 점수는 거의 1에 육박하나, test set의 점수가 터무니없이 낮다

❗ discussion
특성의 개수를 늘리면 선형 모델은 train set에 대해서는 거의 완벽하게 학습하나,
과대적합을 보일 수 있다.

2) 규제(regularization)

규제란
모델의 과대적합을 방지하기 위한 절차로,
선형 회귀 모델의 경우 특성에 따른 계수의 크기를 작게 만드는 것이다.

📕 standard scaling

from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(train_poly)
train_scaled = ss.transform(train_poly)
test_scaled = ss.transform(test_poly)

📕 릿지 회귀

릿지 회귀란
선형 회귀 모델에 규제를 추간한 모델로, 계수를 제곱한 값을 기준으로 규제를 적용한다.
규제의 정도를 alpha라는 하이퍼파라미터로 조절할 수 있다.
alpha값이 클수록 규제가 강하게 들어간다.

from sklearn.linear_model import Ridge
ridge = Ridge()
ridge.fit(train_scaled, train_target)

print(ridge.score(train_scaled, train_target))
▶
0.9896101671037343

print(ridge.score(test_scaled, test_target))
▶
0.9790693977615391

• 결과
  train set의 점수가 조금 낮아졌지만, test set의 점수가 정상으로 돌아왔다.

📕 릿지 회귀 alpha 값 정하기

import matplotlib.pyplot as plt
train_score=[]
test_score=[]

alpha_list = [0.001,0.01,0.1,1,10,100]

for alpha in alpha_list :
    # 릿지 모델 생성
    ridge = Ridge(alpha=alpha)
    # 릿지 모델 훈련
    ridge.fit(train_scaled, train_target)
    # 훈련 점수와 테스트 점수 저장
    train_score.append(ridge.score(train_scaled, train_target))
    test_score.append(ridge.score(test_scaled, test_target))

plt.figure(figsize=(8,8))
plt.plot(np.log10(alpha_list), train_score, label = 'train score')
plt.plot(np.log10(alpha_list), test_score, label = 'test score')
plt.xlabel('alpha')
plt.ylabel('R^2')
plt.legend()
plt.show();

• 결과이미지
  

• 결과
  그래프의 왼쪽을 보면 점수 차이가 아주 크고(과대적합)
  그래프의 오른쪽은 두 점수 모두 낮아지는(과소적합) 모습을 보인다.

❗ discussion
적절한 alpha값은 두 그래프가 가장 가깝고 test set의 점수가 가장 높은 -1, 즉 $10^{-1} = 0.1$이다.

ridge = Ridge(alpha=0.1)
ridge.fit(train_scaled, train_target)

print(ridge.score(train_scaled, train_target))
▶
0.9903815817570365

print(ridge.score(test_scaled, test_target))
▶
0.9827976465386884

• 결과
  이 모델은 두 점수가 비슷하게 모두 높고 과대적합과 과소적합 사이에서 균형을 맞추고 있다.

📕 라쏘 회귀

라쏘 회귀란
선형 회귀 모델에 규제를 추간한 모델로, 계수의 절대값을 기준으로 규제를 적용한다.
규제의 정도를 alpha라는 하이퍼파라미터로 조절할 수 있다.
라쏘 회귀에서는 계수의 값을 아예 0으로 만들 수 있다.

from sklearn.linear_model import Lasso
lasso = Lasso()
lasso.fit(train_scaled, train_target)

print(lasso.score(train_scaled, train_target))
▶
0.989789897208096

print(lasso.score(test_scaled, test_target))
▶
0.9800593698421883

• 결과
  두 점수의 결과 모두 높고 과대적합과 과소적합 사이에 있다.

📕 라쏘 회귀 alpha값 정하기

train_score = []
test_score = []

alpha_list = [0.001, 0.01, 0.1, 1, 10, 100]
for alpha in alpha_list :
    lasso = Lasso(alpha=alpha, max_iter=10000)
    lasso.fit(train_scaled, train_target)
    train_score.append(lasso.score(train_scaled, train_target))
    test_score.append(lasso.score(test_scaled, test_target))

plt.figure(figsize=(8,8))
plt.plot(np.log10(alpha_list), train_score, label = 'train set')
plt.plot(np.log10(alpha_list), test_score, label = 'test set')

plt.xlabel('alpha')
plt.ylabel('$R^2$')
plt.show();

• 결과 이미지
  

❗ discussion
이 그래프 또한 왼쪽은 과대적합, 오른쪽은 과소적합을 보여주고 있다.
점수가 0.98이상이면서 두 점수 차이가 가장 작은 최적의 alpha 값은 $10^{1}=10$이다.
Lasso 클래스의 max_iter는 반복횟수를 정해주는 하이퍼파라미터이다.

lasso = Lasso(alpha=10)
lasso.fit(train_scaled, train_target)

print(lasso.score(train_scaled, train_target))
▶
0.9888067471131867

print(lasso.score(test_scaled, test_target))
▶
0.9824470598706695

# 계수가 0인 특성 개수 확인
print(f'{np.sum(lasso.coef_==0)}/{lasso.coef_.shape[0]}')
▶
40/55

• 결과
  모델이 과대적합과 과소적합 사이에 잘 훈련된 것으로 보이며,
  전체 특성 55개 중 계수가 0인 특성이 40개나 있었다.

❗ discussion
이러한 특징을 통해 라쏘 모델을 유용한 특성을 골라내는 용도로도 사용할 수 있다.

📕 키워드 정리

다중 회귀란
여러 개의 특성을 사용하는 회귀 모델이다.
특성이 많으면 선형 모델은 강력한 성능을 발휘하나, 과대적합될 수 있다.

특성 공학(feature engineering)이란
주어진 특성(feature)을 조합하여 새로운 특성을 만드는 일련의 작업 과정이다.

릿지(Ridge)란
규제가 있는 선형 회귀 모델 중 하나이며 선형 모델의 계수를 작게 만들어 과대적합을 완화시킨다.

라쏘(Lasseo)란
규제가 있는 선형 회귀 모델로, 릿지와 달리 계수값을 아예 0으로 만들 수 있다.

하이퍼파라미터란
머신러닝 알고리즘이 학습하지 않는 파라미터로 모델 학습 시 사전에 직접 지정해줘야 한다.