[혼공머신] 03. 회귀 알고리즘과 모델 규제

지도 학습 알고리즘

- 분류 : 샘플을 몇 개의 클래스 중 하나로 분류

- 회귀 : 정해진 클래스가 없고 임의의 어떤 수치를 예측하는 문제

---

농어(perch) 무게 예측

농어의 길이, 높이, 두께 데이터 있음 ~ 농어 무게 예측 모델 만들고 싶다!

03-1. K-최근접 이웃 회귀

k-최근접 이웃 분류 

예측하려는 샘플에 가장 가까운 샘플 k개를 선택 -> 샘플들의 클래스를 확인

-> 다수 클래스를 새로운 샘플의 클래스로 예측

k=3 (샘플이 3개)라고 가정하면, 사각형이 2개로 다수이기 때문에 샘플 x의 클래스는 사각형

 

k-최근접 이웃 회귀

분류와 똑같이 예측하려는 샘플에 가장 가까운 샘플 k개를 선택

이웃한 샘플의 타깃은 어떤 클래스가 아니라 임의의 수치

타깃 예측 간단한 방법 = 이웃수치들의 평균

이웃한 샘플의 타깃값이 100, 80, 60 이를 평균하면 샘플 x의 예측 타깃값은 80

 

---

데이터 준비

농어의 길이 = 특성, 무게 = 타깃

import numpy as np    # numpy 숫자 파이썬 -> 연산에 필요한 함수 패키지화 되어 저장되어 있음
# numpy를 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])

 

산점도 

하나의 특성을 사용하기 때문에

특성 데이터 x축, 타깃 데이터 y축

import matplotlib.pyplot as plt         # 데이터가 어떤 형태를 띠는지 산점도로 표시!
plt.scatter(perch_length, perch_weight)
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

농어의 길이가 커짐에 따라 무게도 늘어남

 

훈련 세트와 테스트 세트로 나누기

train_test_split( ) 함수 사용

from sklearn.model_selection import train_test_split  # 훈련 세트와 테스트 세트로 나누기
train_input, test_input, train_target, test_target = train_test_split(perch_length, perch_weight, random_state=42) # 책과 동일한 결과를 유지하기 위해 랜덤스테이트 유지

사이킷런에 사용할 훈련 세트는 2차원 배열이어야 함

perch_length가 1차원 배열이기 때문에 이를 나눈 train_input과 test_input도 1차원 배열

1차원 배열을 1개의 열이 있는 2차원 배열로 바꿔줘야 함

1차원 배열의 크기 = 원소가 1개인 튜플

->  크기를 바꿀 수 있는 reshape( ) 사용!

 

ex) [1,2,3] 크기(3, )  -> [[1],[2],[3]] 크기(3,1)

 

 

배열 크기 변경

* reshape( ) : 바꾸려는 배열의 크기를 지정

                  크기가 바뀐 새로운 배열 반환할 때 지정한 크기가 원본 배열에 있는 원소의 개수와 다르면 에러

                  ex) (4, ) -> (2,3) 에러 / 원본 원소 4개인데 2x3=6개로 바꾸려고 해서

크기에 -1 : 나머지 원소 개수로 모두 채우기 (크기 자동 지정)

 

ex) 첫 번째 크기를 나머지 원소 개수로 채우고, 두 번재 크기를 1

     train_input.reshape(-1,1)

# 사이킷런에서 사용할 훈련세트는 2차원 배열, 현재 훈련,테스트 세트는 1차원 배열이므로 변경

train_input = train_input.reshape(-1, 1)  # reshape( )는 배열의 크기를 지정, 크기에 -1을 지정하면 나머지 원소 개수로 모두 채워라!!
test_input = test_input.reshape(-1, 1)

print(train_input.shape, test_input.shape)

(42, 1) (14, 1)

 

reshape(-1, 1) 배열의 전체 원소 개수를 매번 외우지 않아도 되므로 편리

 

---

결정계수(R제곱)

K-최근접 이웃 회귀 알고리즘 클래스 = KNeighborsRegressor

사용법 : 객체를 생성하고 fit( ) 메서드로 회귀 모델 훈련

 

객체 생성 회귀 모델 훈련

# 사이킷런에서 k-최근접 이웃 회귀 알고리즘을 구현한 클래스_KNeighborsRegressor
from sklearn.neighbors import KNeighborsRegressor 
knr = KNeighborsRegressor()

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

 

테스트 세트 점수 확인

print(knr.score(test_input, test_target)

0.992809406101064

 

이 점수는 무엇일까요??

 

분류 : 테스트 세트에 있는 샘플을 정확하게 분류한 개수의 비율 = 정확도 = 정답을 맞힌 개수의 비율

 

회귀 : 예측하는 값이나 타깃 모두 임의의 수치 -> 정확한 숫자 맞히기 불가능

         회귀는 결정계수(R제곱)으로 값을 평가

 

> 결정계수(R제곱) 계산 방법

1. 각 샘플의 타깃과 예측한 값의 차이를 제곱하여 더한다

2. 타깃과 타깃 평균의 차이를 제곱하여 더한 값으로 나눈다

 

타깃의 평균 정도를 예측하는 수준이라면 R제곱은 0에 가까워지고

예측이 타깃에 가까워지면 1에 가까운 값

 

타깃과 예측한 값 사이의 차이를 구해 보면 어느 정도 예측이 벗어났는지 가늠 가능

-> mean_absolute_error 이용

 

* mean_absolute_errror : 타깃과 예측의 절댓값 오차를 평균하여 반환

 

mean_absolute_error (MAE)

# 타깃과 예측한 값 사이의 차이를 구해 보면 예측에 얼마나 벗어났는지 가늠하기 좋다!
# 결과는 타깃값과 얼마나 다른지 알 수 있다.

from sklearn.metrics import mean_absolute_error

# 테스트 세트에 대한 예측을 만듦
test_prediction = knr.predict(test_input)

# 테스트 세트에 대한 평균 절댓값 오차를 계산함
mae = mean_absolute_error(test_target, test_prediction)
print(mae)

19.157142857142862

결과에서 예측이 평균적으로 19 정도 타깃값과 다르다

 

훈련 세트 점수 확인

print(knr.score(train_input, train_target))

0.9698823289099254

 

테스트 세트 0.992809406101064

훈련 세트 0.9698823289099254

---

과대적합 VS 과소적합

과대적합 

훈련 세트에서 점수가 좋았는데, 테스트 세트에서는 점수가 나쁘다

 - 훈련세트에만 잘 맞는 모델이라 테스트 세트와 새로운 샘플에 대한 예측을 만들 때 잘 동작 X

 

과소적합 

훈련 세트보다 테스트 세트의 점수가 높거나, 두 점수가 모두 너무 낮을 경우

 - 모델이 너무 단순하여 훈련세트에 적적히 훈련되지 않은 경우

 

 

테스트 세트 0.992809406101064  >  훈련 세트 0.9698823289099254    -> 과소적합

 

훈련 세트에 더 잘 맞게 만들면 테스트 세트의 점수 조금 낮아짐

K-최근접 이웃 알고리즘으로 모델 더 복잡하게 만드는 방법 : 이웃의 개수 K를 줄이는 것

이웃 개수 줄이면 - 훈련세트에 있는 국지적인 패턴에 민감

이웃 개수 늘리면 - 데이터 전반에 있는 일반적이니 패턴 따름

 

이웃 k 개수 3으로 변경

K-최근접 이웃 알고리즘의 기본 K 값은 5 -> 3으로 낮춰보자

-> n_neighbors 속성값 변경

# 과소적합은 모델을 조금 더 복잡하게 만들면 해결이 됩니다!
# k-최근접 이웃 알고리즘 모델을 더 복잡하게 만드는 방법은 이웃의 개수 k를 줄이기

# 이웃의 개수는 기본 5로 설정되어있는데 3으로 변경
knr.n_neighbors = 3

# 모델을 다시 훈련
knr.fit(train_input, train_target)
print(knr.score(train_input, train_target))

0.9804899950518966

k 값을 줄였더니 훈련 세트의 R제곱 점수가 높아짐

 

테스트 세트 점수 확인

print(knr.score(test_input, test_target))

0.9746459963987609

과소적합 해결

---

03-2. 선형 회귀

k-최근접 이웃의 한계

데이터, 모델 준비 -> 훈련 세트, 테스트 세트로 나누기 -> 최근접 이웃 개수 3 모델

# 훈련 세트와 테스트 세트로 나눔
from sklearn.model_selection import train_test_split

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)

from sklearn.neighbors import KNeighborsRegressor
knr = KNeighborsRegressor(n_neighbors=3)

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

길이가 50cm인 농어 무게 예측

print(knr.predict([[50]]))

[1033.33333333]

실제 농어 무게는 더 나감 뭐가 문제????

 

산점도

훈련 세트, 50cm 농어, 이 농어의 최근접 이웃 표시

k-최근접 이웃 모델 kneighbors( ) 메서드 사용 - 가장 가까운 이웃까지의 거리와 이웃 샘플 인덱스 get

import matplotlib.pyplot as plt

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

# 훈련 세트의 산점도 그리기
plt.scatter(train_input, train_target)

# 훈련 세트 중에서 이웃 샘플만 다시 그리기
plt.scatter(train_input[indexes], train_target[indexes], marker='D')

# 50cm 농어 데이터
plt.scatter(50, 1033, marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()                      # 50cm 농어의 가장 가까운 것은 45cm 근방이기 떄문에 주볁 샘플들의 무게를 평균하면 실제 값과 차이 존재

길이가 50cm 무게가 1033g 농어는 ▲(marker='^')로 표시 그 주변의 샘플은 ◆(marker='D') 

50cm 농어에서 가장 가까운 것은 45cm 근방 - k-최근접 이웃 알고리즘은 이 샘플들 무게 평균

 

이웃 샘플의 타깃 평균

# 이웃샘플의 타깃의 평균을 구해보자!

print(np.mean(train_target[indexes]))   # 모델이 예측한 값과 일치. 가장 가까운 샘플을 찾아 타깃을 예측하면 엉뚱한 값을 예측할 수 있음

1033.3333333333333

 

모델이 예측한 값과 일치

k-최근접 이웃 회귀는 가장 가까운 샘플을 찾아 타깃을 평균함

-> 새로운 샘플이 훈련 세트의 범위를 벗어나면 엉뚱한 값 예측

 

길이 100cm 예측

# 예를 들어 길이가 100cm 농어도 아마도 1,033g으로 예측할 것으로 추측됨

print(knr.predict([[100]]))

[1033.33333333]

 

산점도

# 그래프로 그려서 확인해보자
distances, indexes = knr.kneighbors([[100]])

# 훈련 세트의 산점도 그리기
plt.scatter(train_input, train_target)

# 훈련 세트 중에서 이웃 샘플만 다시 그리기
plt.scatter(train_input[indexes], train_target[indexes], marker='D')

# 100cm 농어 데이터
plt.scatter(100, 1033, marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()                        # 이런 식이면 농어가 아무리 커도 무게가 더 늘어나지 않는다!

이런 식이면 농어가 아무리 커도 무게가 더 늘어나지 않음

-> 다른 모델 찾아보자

 

선형 회귀

특성이 하나인 경우 어떤 직선을 학습하는 알고리즘

그 특성을 가장 잘 나타낼 수 있는 직선 찾기

sklearn.linear_model 패키지 아래 LinearRegression 클래스로 선형 회귀 알고리즘 구현

 

( 사이킷런 모델 클래스는 fit( ) 훈련, score( ) 평가, predict( ) 예측 메서드 이름 모두 동일)

## 선형 회귀_ 직선을 학습하는 알고리즘

from sklearn.linear_model import LinearRegression
lr = LinearRegression()

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

# 50cm 농어에 대해 예측
print(lr.predict([[50]]))

[1241.83860323]

 

k-최근접 이웃 회귀보다 선형 회귀가 농어의 무게를 아주 높게 예측

-> 선형 회귀가 학습한 직선 그려 보자

 

하나의 직선을 그리려면 기울기와 절편이 있어야 함

y = a * x + b 

 

x를 농어의 길이, y를 농어의 무게로 바꾸면 위와 같은 그래프

 

 

lr객체 기울기 절편 

LinearRegression 클래스가 찾은 a(기울기), b(절편)는 lr 객체의 coef_ (기울기) 와 intercept_ (절편) 속성에 저장

print(lr.coef_, lr.intercept_)

[39.01714496] -709.0186449535477

-> 기울기 39.0174496  절편 -709.0186449535477

 

* 모델 파라미터 : coef_ intercept_ 처럼 머신러닝 알고리즘이 찾은 값

 

훈련 세트의 산점도, 직선 그리기

농어 길이 15에서 50까지 직선

(15, 15*39 -709)와 (50, 50*39 -709) 두 점을 이으면 됨

농어의 길이 15에서 50까지 직선으로 그려서 그림으로 보자!

# 훈련 세트의 산점도를 그림
plt.scatter(train_input, train_target)

# 15에서 50까지 1차 방정식 그래프를 그림
plt.plot([15, 50], [15*lr.coef_+lr.intercept_, 50*lr.coef_+lr.intercept_])

# 50cm 농어 데이터
plt.scatter(50, 1241.8, marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

# 길이가 50cm인 농어의 예측이 직선의 연장선에 있다는 것을 알 수 있음.

선형 회귀 알고리즘이 이 데이터셋에서 찾은 최적의 직선

-> 훈련 세트 범위 벗어난 농어 무게 예측 가능!

 

훈련 세트, 테스트 세트에 대한 R제곱 점수 확인

# 훈련 세트와 테스트 세트에 대한 R^2점수를 확인
print(lr.score(train_input, train_target)) # 훈련 세트
print(lr.score(test_input, test_target))   # 테스트 세트

훈련, 테스트 세트 점수 높지 않음... 과소적합

---

다항 회귀

선형 회귀가 만든 직선은 왼쪽 아래로 쭉 뻗어 있음

이 직선대로라면 농어의 무게가 0g 이하로 내려감 .. 있을 수 없는일!

 

농어 길이와 무게에 대한 산점도를 보면 일직선이라기보다 왼쪽 위로 조금 구부러진 곡선

2차 방정식의 그래프를 그리려면 길이를 제곱한 항이 훈련 세트에 추가되어야 함

 

농어의 길이를 제곱해서 원래 데이터 앞에 붙이기

* column_stack( ) : 1차원의 배열을 2차원 배열에 열로 쌓는다

train_input을 제곱한 것과 train_input 두 배열을 나란히 붙이기 test_input도 마찬가지

# 직선대로 예측하면 농어의 무게가 0g 이하인 -까지 내려갈텐데 현실에서는 있을수 없다!
# -가 아닌 곡선에 가까우므로 최적의 곡선을 찾는게 보다 현실적이다!

## 다항 회귀_ 2차방정식의 그래프를 그리려면 제곱한 항이 훈련세트에 추가
# 농어의 길이를 제곱하여 데이터 앞에 추가
train_poly = np.column_stack((train_input ** 2, train_input))
test_poly = np.column_stack((test_input ** 2, test_input))

train_input **2 식에도 넘파이 브로드캐스팅 적용

= train_input에 있는 모든 원소를 제곱한다

 

새롭게 만든 데이터셋 크기 확인

# 모든 원소를 제곱하여 데이터 셋의 크기를 확인
print(train_poly.shape, test_poly.shape)

(42, 2) (14, 2)

원래 특성인 길이를 제곱하여 왼쪽 열에 추가했기 때문에 훈련 세트, 테스트 세트 모두 열이 2개로 늘어남

 

 

train_poly 사용 선형 회귀 모델 다시 훈련

2차 방정식 그래프를 찾기 위해 훈련 세트 제곱 항을 추가했지만, 타깃값은 그대로 사용

목표하는 값은 어떤 그래프를 훈련하든 바꿀 필요 X

 

테스트할 때는 이 모델에 농어 길이의 제곱과 원래 길이를 함께 넣어야 함

# 선형회귀 모델을 훈련한 다음 50cm 농어에 대해 무게 예측 
lr = LinearRegression()
lr.fit(train_poly, train_target)

print(lr.predict([[50**2, 50]]))    # 앞서 훈련한 모델보다 더 높은 값을 예측함

[1573.98423528]

 

모델이 훈련한 계수와 절편 출력

print(lr.coef_, lr.intercept_)

[ 1.01433211 -21.55792498] 116.0502107827827

 

무게 = 1.01 * 길이제곱 - 21.6 * 길이 + 116.05

 

이런 방정식을 다항식이라 부르며, 다항식을 사용한 선형 회귀를 다항 회귀라 함

 

훈련 세트의 산점도에 그래프

짧은 직선을 이어서 그리면 마치 곡선처럼 표현 가능1씩 짧게 끊어서 그리기

#다항회귀의 산점도 그래프를 그려서 눈으로 확인해보자! 

# 구간별 직선을 그리기 위해 15에서 49까지 정수 배열을 만듦
point = np.arange(15, 50)

# 훈련 세트의 산점도를 그림
plt.scatter(train_input, train_target)

# 15에서 49까지 2차 방정식 그래프를 그림
plt.plot(point, 1.01*point**2 - 21.6*point + 116.05)

# 50cm 농어 데이터
plt. scatter([50], [1574], marker= '^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

훈련 세트의 경향을 잘 따르고, 무게가 음수로 나오지 X

 

훈련 세트와 테스트 세트의 R제곱 점수 평가

# 훈련 세트와 테스트 세트의 R^2 점수를 평가해보자
print(lr.score(train_poly, train_target))
print(lr.score(test_poly, test_target))   # 과소적합이 남아있으므로 조금 더 복잡한 모델이 필요함.

0.9706807451768623

0.9775935108325122

 

과소적합이 남아 있음 -> 조금 더 복잡한 모델 필요

---

3-3. 특성 공학과 규제

다중 회귀

여러 개의 특성을 사용한 선형 회귀

 

특성 1개 - 직선 학습

특성 2개 - 평면 학습

              타깃 = a * 특성1 + b * 특성2 + 절편

 

특성공학 : 기존의 특성을 사용해 새로운 특성을 뽑아내는 작업

---

데이터 준비

* 판다스 : 데이터 분석 라이브러리. 데이터프레임은 판다스의 핵심 데이터 구조

# 조금더 복잡한 모델을 만드려면 제곱보다 더 고차항을 넣어야 하는데 특징을 추가해서 고차항으로 만들자
# 특성 공학 - 기존의 특성을 사용해 새로운 특성을 뽑아내 특징을 추가

## 데이터 준비
import pandas as pd     # pd는 관례적으로 사용하는 판다스의 별칭
df = pd.read_csv('http://bit.ly/perch_csv')
perch_full = df.to_numpy()
print(perch_full)

read.csv() 함수로 데이터프레임 만든 다음 to_numpy() 메서드를 사용해 넘파이 배열로 변경

 

타깃 데이터 준비

import numpy as np
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])

 

훈련 세트와 테스트 세트

perch_full과 perch_weight를 훈련 세트와 테스트 세트로 나눈다

# 훈련 세트와 테스트 세트로 나누기
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)

---

사이킷런 변환기

사이킷런은 특성을 만들거나 전처리하기 위한 다양한 클래스 제공. 이런 클래스를 변환기라고 함

모델 클래스 - fit( ), score( ), predict( )

변환기 클래스 - fit( ), transform( )

 

사용할 변환기는 polynomialfeatures 클래스

sklearn.preprocessing 패키지에 포함되어 있음

## 사이킷런의 변환기_ 특성을 만들거나 전처리하기 위한 다양한 클래스 제공
from sklearn.preprocessing import PolynomialFeatures

 

클래스 객체 -> fit() -> transform()

훈련(fit)을 해야 변환(transform) 가능

# 예시1
poly = PolynomialFeatures()
poly.fit([[2, 3]])               # 훈련 fit을 해야 변환 transform이 가능함 
print(poly.transform([[2, 3]]))   # 1은 절편에 곱해진 수

[[1. 2. 3. 4. 6. 9.]]

 

fit( ) 메서드 새롭게 만들 특성 조합 찾고 transform( ) 메서드는 실제로 데이터를 변환

변환기는 입력 데이터를 변환하는 데 타깃 데이터가 필요하지 않음

모델 클래스와 다르게 fit( ) 메서드에 입력 데이터만 전달

 

PolynomialFeatures 각 특성을 제곱한 항을 추가하고 특성끼리 서로 곱한 항 추가

[[1 , 2 , 3 , 2*2, 2*3, 3*3 ]]

1이 추가된 이유?

무게 = a*길이 + b*높이 + c*두께 +d*1

선형 방정식의 절편을 항상 값이 1인 특성과 곱해지는 계수

특성은 (길이, 높이, 두께, 1)이 됨

하지만 사이킷런 선형 모델은 자동으로 절편추가 하므로 굳이 1 특성 만들필요 x

include_bias=False 지정 1 제거

# 예시2
poly = PolynomialFeatures(include_bias=False) # 사이킷 런 선형모델은 자동 절편을 추가하므로 제거 
poly.fit([[2,3]])
print(poly.transform([[2, 3]]))

[[2. 3. 4. 6. 9.]]

 

절편을 위한 항이 제거되고 특성의 제곱과 특성끼리 곱한 항만 추가됨

 

이 방식으로 train_input 적용

train_input을 변환한 데이터 train_poly 저장, 배열 크기 확인

# 특성 만들기를 적용, 배열의 크기를 확인_9개의 특성
poly = PolynomialFeatures(include_bias=False)
poly.fit(train_input)
train_poly = poly.transform(train_input)
print(train_poly.shape)

(42, 9)

 

특성 조합

* get_feature_names_out( ) : 특성이 각각 어떤 입력의 조합을 만들어졌는지 알려줌

# 9개의 특성이 각각 어떤 입력의 조합으로 만들어졌는가
poly.get_feature_names()

['x0', 'x1', 'x2', 'x0^2', 'x0 x1', 'x0 x2', 'x1^2', 'x1 x2', 'x2^2']

 

x0 첫번째 특성

x0^2 첫번째 특성의 제곱

x0 x1 첫번째 특성과 두번쨰 특성의 곱

 

테스트 세트 변환

# 테스트 세트로 변환하여 다중 회귀 모델을 훈련하자
test_poly = poly.transform(test_input)

---

다중 회귀 모델 훈련하기

LinearRegression 클래스 임포트, train_ploy 사용 모델 훈련

## 다중 회귀 모델 훈련하기

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))   # 앞선 과소적합 문제는 더이상 나타나지 않음

 

특성 추가

* degree : 필요한 고차항의 최대 차수 지정

#특성을 더 많이 추가하면 어떨까? 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)   # 만들어진 특성의 개수가 55개나 된다!

(42, 55)

train_poly 배열의 열의 개수가 특성의 개수

특성 55개

 

선형 회귀 모델 다시 훈련

# 5제곱 특성을 적용한 선형 회귀 모델을 다시 훈련해보자
lr.fit(train_poly, train_target)
print(lr.score(train_poly, train_target))   # 거의 완벽에 가까운 점수가 나타남!

0.9999999999991097

 

테스트 세트 점수 확인

# 5제곱 특성을 적용한 테스트 세트에 대한 점수를 알아보자
print(lr.score(test_poly, test_target))     # 과대적합되어 테스트 점수에서는 형편없는 점수를 나타냄

특성의 개수를 크게 늘리면 선형 모델은 아주 강력해짐

훈련 세트에 대해 거의 완벽하게 학습

하지만 이런 모델은 훈련 세트에 너무 과대적합 - 테스트 세트에서는 형편없는 점수

 

---

규제

머신러닝 모델이 훈련 세트를 너무 과도하게 학습하지 못하도록 훼방하는 것

 

특성의 스케일이 정규화되지 않으면 여기에 곱해지는 계수 값도 차이 나게 됨

선형 회귀 모델에 규제를 적용할 때 계수 값의 크기가 서로 많이 다르면 공정하게 제어 X

먼저 정규화 !  StandafdScaler 클래스 사용

## 규제_너무 과도하게 학습하지 않도록 훼방하자!

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
ss.fit(train_poly)

train_scaled = ss.transform(train_poly)   # training set과 같은 기준을 적용
test_scaled = ss.transform(test_poly)

StandadScaler 클래스의 객체 ss를 초기화한 후 PoltnomialFeatures 클래스로 만든 train_poly 사용해 객체 훈련

훈련 세트로 학습한 변환기를 사용해 테스트 세트까지 변환

 

 

 

 

---

참고도서 : 혼자공부하는 머신러닝 + 딥러닝, 박해선, 한빛미디어, 2020년