LinearRegression, Ridge, Lasso 알고리즘

 

 

 

• 사용 데이터셋 : iris, forge,
• 사용 모델 : KNN, LinearRegression, Ridge, Lasso

 

 

 

In [1]:

from sklearn.model_selection import train_test_split
from sklearn.datasets import make_blobs
import mglearn

# x값에 따른 y값 형태의 dataset을 생성
# 사용되는 데이터셋은 forge() 형태
x, y = mglearn.datasets.make_forge()

# 전체 데이터셋을 train데이터와 test데이터로 생성
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0)

 

In [2]:

# KNN Classifier 러닝 모델 사용 선언
from sklearn.neighbors import KNeighborsClassifier

# NKK에서 사용되는 이웃의 수는 3개
clf = KNeighborsClassifier(n_neighbors=3)

In [3]:

# 데이터 형식 출력
clf.fit(x_train, y_train)

Out[3]:

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=3, p=2,
           weights='uniform')

In [4]:

print("테스트 세트 예측 : {}".format(clf.predict(x_test)))
print("테스트 세트 정확도 : {:.2f}".format(clf.score(x_test, y_test)))

 

테스트 세트 예측 : [1 0 1 0 1 0 0]
테스트 세트 정확도 : 0.86

In [5]:

# wave 데이터 형태에서 KNN알고리즘은
# KNeighborsRegressor 를 사용하여 회귀 분석
from sklearn.neighbors import KNeighborsRegressor

# 데이터셋에서 사용되는 셈플의 수는 40개
x, y = mglearn.datasets.make_wave(n_samples=40)

# test데이터와 train데이터 분류
# 데이터의 변화는 X
x_train, x_test, y_train, y_test = train_test_split(x,y, random_state=0)

# Regressor 회귀 모델 선언
# KNN에서 이웃 K의 수는 3으로 고정
reg = KNeighborsRegressor(n_neighbors=3)

# 데이터 모델 피팅
reg.fit(x_train, y_train)

Out[5]:

KNeighborsRegressor(algorithm='auto', leaf_size=30, metric='minkowski',
          metric_params=None, n_jobs=1, n_neighbors=3, p=2,
          weights='uniform')

In [6]:

print("테스트 세트 예측 : \n{}".format(reg.predict(x_test)))

 

테스트 세트 예측 : 
[-0.05396539  0.35686046  1.13671923 -1.89415682 -1.13881398 -1.63113382
  0.35686046  0.91241374 -0.44680446 -1.13881398]

In [7]:

# 음수 제거를 위해 결과 값에 제곱을 수행
print("테스트 세트 R^2 : {:.2f}".format(reg.score(x_test, y_test)))

 

테스트 세트 R^2 : 0.83

In [8]:

# 최소제곱법
# wave데이터 셋을 선형 회귀 분석을 수행하기 위해 LinearRegression모델 선언
from sklearn.linear_model import LinearRegression

# 셈플 데이터셋 60개 사용
x, y = mglearn.datasets.make_wave(n_samples=60)
# 데이터셋의 변화는 렌덤으로 변경
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=42)

# train데이터를 LinearRegression으로 피팅
lr = LinearRegression().fit(x_train, y_train)

In [9]:

print("lr.coef : {}".format(lr.coef_))
print("lr.intercept_ : {}".format(lr.intercept_))

 

lr.coef : [0.39390555]
lr.intercept_ : -0.031804343026759746

In [10]:

print("훈련 세트 점수 : {:.2f}".format(lr.score(x_train, y_train)))
print("테스트 세트 점수 : {:.2f}".format(lr.score(x_test, y_test)))

 

훈련 세트 점수 : 0.67
테스트 세트 점수 : 0.66

In [11]:

#보스턴 주택 데이터 셋을 이용한 최소 제곱법
x, y = mglearn.datasets.load_extended_boston()

# 주택의 가격은 연속적인 선형 회귀모델로 분석
# 데이터 셋의 변경은 X
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0)
# 데이터 셋을 모델에 피팅
lr = LinearRegression().fit(x_train, y_train)

In [12]:

print("훈련 세트 점수 : {:.2f}".format(lr.score(x_train, y_train)))
print("테스트 세트 점수 : {:.2f}".format(lr.score(x_test, y_test)))

 

훈련 세트 점수 : 0.95
테스트 세트 점수 : 0.61

In [13]:

# 가중치 최소화를 위한 Ridge모델 선언
from sklearn.linear_model import Ridge

# 보스턴 주택 데이터 셋에서 train데이터 셋을 Ridge모델에 피팅
ridge = Ridge().fit(x_train, y_train)

print("훈련 세트 점수 : {:.2f}".format(ridge.score(x_train,y_train)))
print("테스트 세트 점수 : {:.2f}".format(ridge.score(x_test,y_test)))

 

훈련 세트 점수 : 0.89
테스트 세트 점수 : 0.75

In [14]:

# Ridge의 alpha를 10
# alpha : 모델의 복잡도
ridge10 = Ridge(alpha=10).fit(x_train, y_train)

print("훈련 세트 점수 : {:.2f}".format(ridge10.score(x_train,y_train)))
print("테스트 세트 점수 : {:.2f}".format(ridge10.score(x_test,y_test)))

 

훈련 세트 점수 : 0.79
테스트 세트 점수 : 0.64

In [15]:

# alpha 값을 0.1로 수정
ridge01 = Ridge(alpha=0.1).fit(x_train, y_train)

print("훈련 세트 점수 : {:.2f}".format(ridge01.score(x_train,y_train)))
print("테스트 세트 점수 : {:.2f}".format(ridge01.score(x_test,y_test)))

 

훈련 세트 점수 : 0.93
테스트 세트 점수 : 0.77

In [16]:

# 값을 그리기 위한 그래프 라이브러리 출력
%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 7))
# 선형 회귀 분석을 위한 LinearRegression 모델 선언
from sklearn.linear_model import LinearRegression

lr = LinearRegression().fit(x_train, y_train)

# alpha 값이 1, 10, 0.1일 경우를 각각 출력
plt.plot(ridge10.coef_, '^', label="Reidge alpha = 10")
plt.plot(ridge.coef_, 's', label="Reidge alpha = 1")
plt.plot(ridge01.coef_, 'v', label="Reidge alpha = 0.1")

# 선형 회귀 모델의 그래프와 함께 출력
plt.plot(lr.coef_, 'o', label="LinearRegression")
plt.xlabel("계수 목록")
plt.ylabel("계수 크기")
plt.hlines(0, 0, len(lr.coef_))
plt.ylim(-25,25)
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))

Out[16]:

<matplotlib.legend.Legend at 0x2ab5eebc6d8>

 

In [17]:

# MgLearn으로 사용 될 Ridge 셈플 데이터 그래프
mglearn.plots.plot_ridge_n_samples()

 

In [18]:

# Lasso모델을 사용하기 위한 모델 선언
# 가중치를 0으로 만들어서 예측하는 기법
from sklearn.linear_model import Lasso
# 모델의 값을 행과 열로 된 데이터로 만들기 위한 NumPy 라이브러리 선언
import numpy as np

# Lasso모델을 이용해 트레이닝 데이터를 피팅
lasso = Lasso().fit(x_train, y_train)
# Normal 상태의 Lasso모델로 피팅시킨 상태의 예측값
# Normal 상태의 alpha값은 1.0
print("훈련 세트 점수 : {:.2f}".format(lasso.score(x_train,y_train)))
print("테스트 세트 점수 : {:.2f}".format(lasso.score(x_test,y_test)))
print("사용한 특성의 개수 : {}".format(np.sum(lasso.coef_ != 0)))
# 출력 결과는 과소적합
# 테스트에 사용된 특성의 개수가 너무 적음

 

훈련 세트 점수 : 0.29
테스트 세트 점수 : 0.21
사용한 특성의 개수 : 4

In [19]:

# alpha값을 0.01로 수정
lasso001 = Lasso(alpha=0.01, max_iter=100000).fit(x_train, y_train)
print("훈련 세트 점수 : {:.2f}".format(lasso001.score(x_train,y_train)))
print("테스트 세트 점수 : {:.2f}".format(lasso001.score(x_test,y_test)))
print("사용한 특성의 개수 : {}".format(np.sum(lasso001.coef_ != 0)))

 

훈련 세트 점수 : 0.90
테스트 세트 점수 : 0.77
사용한 특성의 개수 : 33

In [20]:

lasso00001 = Lasso(alpha=0.0001, max_iter=100000).fit(x_train, y_train)
print("훈련 세트 점수 : {:.2f}".format(lasso00001.score(x_train,y_train)))
print("테스트 세트 점수 : {:.2f}".format(lasso00001.score(x_test,y_test)))
print("사용한 특성의 개수 : {}".format(np.sum(lasso00001.coef_ != 0)))
# 트레이닝 데이터의 점수가 95%인 반면 테스트 점수는 64%인 것으로 볼 때
# 해당 모델은 오버피팅이 된 결과

 

훈련 세트 점수 : 0.95
테스트 세트 점수 : 0.64
사용한 특성의 개수 : 94

In [21]:

plt.plot(lasso.coef_, 's', label="Lasso alpha = 1")
plt.plot(lasso001.coef_, '^', label="Lasso alpha = 0.01")
plt.plot(lasso00001.coef_, 'v', label="Lasso alpha = 0.0001")

plt.plot(ridge01.coef_, 'o', label="Reidge alpha = 0.1")
plt.legend(ncol=2, loc=(0,1.05))
plt.ylim(-25,25)
plt.xlabel("Coefficient List")
plt.ylabel("Coefficient size")

Out[21]:

Text(0,0.5,'Coefficient size')