[머신러닝] #3 선형 모델 Linear Models

뚠뚠이뚠뚠이 2021. 12. 20. 15:07

2021. 12. 20. 15:07

### 2021.12.20

선형 모델(Linear Models)

선형 모델은 과거 부터 지금 까지 널리 사용되고 연구 되고 있는 기계학습 방법
선형 모델은 입력 데이터에 대한 선형 함수를 만들어 예측 수행
회귀 분석을 위한 선형 모델은 다음과 같이 정의

$x$ : 입력 데이터
$w$ : 모델이 학습할 파라미터
$w_{0}$ : 편향
$w_{1}$ ~ $w_{p}$ : 가중치

선형 회귀(Linear Regression)

선형 회귀(Linear Regression)또는 최소제곱법(Ordinary Least Squares)은 가장 간단한 회귀 분석을 위한 선형 모델
선형 회귀는 모델의 예측과 정답 사이의 평균제곱오차(Mean Squared Error)를 최소화 하는 학습 파라미터 $w$ 를 찾음
평균제곱오차는 아래와 같이 정의

$y$ : 정답
$\hat{y}$ : 예측 값을 의미

선형 회귀 모델에서 사용하는 다양한 오류 측정 방법
- MAE(Mean Absoulte Error)
- MAPE(Mean Absolute Percentage Error)
- MSE(Mean Squared Error)
- MPE(Mean Percentage Error)

#In[1]
import numpy as np
import matplotlib.pyplot as plt
plt.style.use(['seaborn-whitegrid'])

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

noise = np.random.rand(100, 1)
X = sorted(10 * np.random.rand(100,1)) + noise
y = sorted(10 * np.random.rand(100))

#In[2]
plt.scatter(X,y)

#Out[2]

#In[]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

model = LinearRegression()
model.fit(X_train, y_train)

#Out[]
LinearRegression()

#In[1]
print("선형 회귀 가중치 : {}".format(model.coef_))
print("선형 회귀 편향 : {}".format(model.intercept_))
#Out[1]
선형 회귀 가중치 : [1.02525962]
선형 회귀 편향 : -0.26433640350999

#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))
#Out[2]
학습 데이터 점수 : 0.9782833986327462
평가 데이터 점수 : 0.976790278445786

#In[]
predict = model.predict(X_test)

plt.scatter(X_test, y_test)
plt.plot(X_test, predict, '--r')

#Out[]

보스턴 주택 가격 데이터

주택 가격 데이터는 도시에 대한 분석과 부동산, 경제적인 정보 분석 등 많은 활용 가능한 측면들이 존재
보스턴 주택 가격 데이터는 카네기 멜론 대학교에서 관리하는 StatLib 라이브러리에서 가져온 것
헤리슨(Harrison, D.)과 루빈펠트(Rubinfeld, D. L.)의 논문 "Hedonic prices and the demand for clean air', J. Environ. Economics & Management"에서 보스턴 데이터가 사용
1970년도 인구 조사에서 보스턴의 506개 조사 구역과 주택 가격에 영향을 주는 속성 21개로 구성

#In[]
from sklearn.datasets import load_boston

boston = load_boston()
print(boston.keys())
print(boston.DESCR)

#Out[]
dict_keys(['data', 'target', 'feature_names', 'DESCR', 'filename', 'data_module'])
.. _boston_dataset:

Boston house prices dataset
---------------------------

**Data Set Characteristics:**  

    :Number of Instances: 506 

    :Number of Attributes: 13 numeric/categorical predictive. Median Value (attribute 14) is usually the target.

    :Attribute Information (in order):
        - CRIM     per capita crime rate by town
        - ZN       proportion of residential land zoned for lots over 25,000 sq.ft.
        - INDUS    proportion of non-retail business acres per town
        - CHAS     Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
        - NOX      nitric oxides concentration (parts per 10 million)
        - RM       average number of rooms per dwelling
        - AGE      proportion of owner-occupied units built prior to 1940
        - DIS      weighted distances to five Boston employment centres
        - RAD      index of accessibility to radial highways
        - TAX      full-value property-tax rate per $10,000
        - PTRATIO  pupil-teacher ratio by town
        - B        1000(Bk - 0.63)^2 where Bk is the proportion of black people by town
        - LSTAT    % lower status of the population
        - MEDV     Median value of owner-occupied homes in $1000's

#In[]
import pandas as pd

boston_df = pd.DataFrame(boston.data, columns=boston.feature_names)
boston_df['MEDV'] = boston.target
boston_df.head()

#Out[]

#In[]
boston_df.describe()

#Out[]

#In[]
for i, col in enumerate(boston_df.columns):
    plt.figure(figsize=(8,4))
    plt.plot(boston_df[col])
    plt.title(col)
    plt.xlabel('Town')
    plt.tight_layout()

#Out[]
각 feature에 대한 그래프 출력

#In[]
for i, col in enumerate(boston_df.columns):
    plt.figure(figsize=(8,4))
    plt.scatter(boston_df[col], boston_df['MEDV'])
    plt.ylabel('MEDV', size = 12)
    plt.xlabel(col, size = 12)
    plt.tight_layout()
    
#Out[]
각 feature에 대한 그래프 출력

#In[]
import seaborn as sns
sns.pairplot(boston_df)

#Out[]
13 X 13 에 대한 그래프 출력

보스턴 주택 가격에 대한 선형 회귀

#In[]
from sklearn.linear_model import LinearRegression
medel = LinearRegression(normalize=True)

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.3)
model.fit(X_train, y_train)

#Out[]
LinearRegression()

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.720438846769244
평가 데이터 점수 : 0.7741844698985254

데이터를 두개로 분리하고 모델을 생성 및 검증하였지만, 데이터를 분리하였기 때문에 훈련에 사용할 수 있는 양도 작아지고, 분리가 잘 안된 경우에는 잘못된 검증이 될 수 있음
이럴 경우에는 테스트셋을 여러개로 구성하여 교차 검증을 진행
cross_val_score() 함수는 교차 검증을 수행하여 모델을 검증
다음 예제에서는 모델 오류를 측정하는 점수로 NMSE(Negative Mean Squared Error)를 사용

#In[]
from sklearn.model_selection import cross_val_score

scores = cross_val_score(model, boston.data, boston.target, cv=10, scoring='neg_mean_squared_error')
print('NMSE scores : {}'.format(scores))
print('NMSE scores mean : {}'.format(scores.mean()))
print('NMSE scores std : {}'.format(scores.std()))

#Out[]
NMSE scores : [  -9.28694671  -14.15128316  -14.07360615  -35.20692433  -31.88511666
  -19.83587796   -9.94726918 -168.37537954  -33.32974507  -10.96041068]
NMSE scores mean : -34.705255944524914
NMSE scores std : 45.57399920030867

회귀모델의 검증을 위한 또 다른 측정 지표 중 하나로 결정 계수(coefficient of determination, $R^{2}$ ) 사용

#In[]
r2_scores = cross_val_score(model, boston.data, boston.target, cv=10, scoring='r2')

print('R2 scores : {}'.format(r2_scores))
print('R2 scores mean : {}'.format(r2_scores.mean()))
print('R2 scores std : {}'.format(r2_scores.std()))

#Out[]
R2 scores : [ 0.73376082  0.4730725  -1.00631454  0.64113984  0.54766046  0.73640292
  0.37828386 -0.12922703 -0.76843243  0.4189435 ]
R2 scores mean : 0.20252899006055863
R2 scores std : 0.5952960169512364

생성된 회귀 모델에 대해서 평가를 위해 LinearRegression 객체에 포함된 두 개의 속성 값을 통해 수식을 표현

intercept_: 추정된 상수항
coef_: 추정된 가중치 벡터

#In[]
print('y = ' + str(model.intercept_) + ' ')
for i, c in enumerate(model.coef_):
    print(str(c) + ' * x' + str(i))
    
#Out[]
y = 42.321077872060854 
-0.10105235411092622 * x0
0.04348245969543986 * x1
0.018691385811833685 * x2
3.0976529601010103 * x3
-19.887702239501845 * x4
3.136164405534508 * x5
0.008906966537697883 * x6
-1.4967491742091585 * x7
0.28631777507480266 * x8
-0.008359295564382759 * x9
-1.0235500260398487 * x10
0.009269802610719184 * x11
-0.6134051726203665 * x12

RMSE와 R2 score 비교

#In[]
from sklearn.metrics import mean_squared_error, r2_score

y_train_predict = model.predict(X_train)
rmse = (np.sqrt(mean_squared_error(y_train, y_train_predict)))
r2 = r2_score(y_train, y_train_predict)

print('RMSE : {}'.format(rmse))
print('R2 score : {}'.format(r2))

#Out[]
RMSE : 4.8217885054922185
R2 score : 0.720438846769244

#In[]
from sklearn.metrics import mean_squared_error, r2_score

y_test_predict = model.predict(X_test)
rmse = (np.sqrt(mean_squared_error(y_test, y_test_predict)))
r2 = r2_score(y_test, y_test_predict)

print('RMSE : {}'.format(rmse))
print('R2 score : {}'.format(r2))

#Out[]
RMSE : 4.440697444558274
R2 score : 0.7741844698985254

True price VS Predicted price

#In[]
def plot_boston_prices(expected, predicted):
    plt.figure(figsize=(8, 4))
    plt.scatter(expected, predicted)
    plt.plot([5, 50], [5, 50], '--r')
    plt.xlabel('True price ($1,000s)')
    plt.ylabel('Predicted price ($1,000s)')
    plt.tight_layout()
    
predicted = model.predict(X_test)
expected = y_test

plot_boston_prices(expected, predicted)

#Out[]

캘리포니아 주택 가격 데이터

#In[]
from sklearn.datasets import fetch_california_housing

california = fetch_california_housing()
print(california.keys())
print(california.DESCR)

#Out[]
dict_keys(['data', 'target', 'frame', 'target_names', 'feature_names', 'DESCR'])
.. _california_housing_dataset:

California Housing dataset
--------------------------

**Data Set Characteristics:**

    :Number of Instances: 20640

    :Number of Attributes: 8 numeric, predictive attributes and the target

    :Attribute Information:
        - MedInc        median income in block group
        - HouseAge      median house age in block group
        - AveRooms      average number of rooms per household
        - AveBedrms     average number of bedrooms per household
        - Population    block group population
        - AveOccup      average number of household members
        - Latitude      block group latitude
        - Longitude     block group longitude

    :Missing Attribute Values: None

This dataset was obtained from the StatLib repository.
https://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.html

The target variable is the median house value for California districts,
expressed in hundreds of thousands of dollars ($100,000).

#In[]
import pandas as pd

california_df = pd.DataFrame(california.data, columns = california.feature_names)
california_df['Target'] = california.target
california_df.head()

#Out[]

#In[]
california_df.describe()

#Out[]

#In[]
import matplotlib.pyplot as plt

for i, col in enumerate(california_df.columns):
    plt.figure(figsize=(8,5))
    plt.plot(california_df[col])
    plt.title(col)
    plt.tight_layout()
    
#Out[]
각 feature마다 그래프 출력

#In[]
import matplotlib.pyplot as plt

for i, col in enumerate(california_df.columns):
    plt.figure(figsize=(8,5))
    plt.scatter(california_df[col], california_df['Target'])
    plt.ylabel('Target', size=12)
    plt.xlabel(col,size=12)
    plt.title(col)
    plt.tight_layout()
    
#Out[]
각 feature마다 그래프 출력

#In[]
import seaborn as sns

sns.pairplot(california_df.sample(1000))

#Out[]
9 X 9개의 그래프 출력

#In[]
california_df.plot(kind='scatter', x='Longitude', y='Latitude', alpha=0.2,figsize=(12,10))

#Out[]

#In[]
california_df.plot(kind='scatter', x='Longitude', y='Latitude', alpha=0.2,
                   s=california_df['Population']/100, label='Population', figsize=(15,10),
                  c ='Target', cmap=plt.get_cmap('viridis'), colorbar=True)

#Out[]

캘리포니아 주택 가격에 대한 선형 회귀

#In[]
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

model= LinearRegression(normalize=True)
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)

model.fit(X_train, y_train)
print('학습 데이터 점수 : {}'.format(model.score(X_train, y_train)))
print('평가 데이터 점수 : {}'.format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.602352118468718
평가 데이터 점수 : 0.610740117378534

#In[]
from sklearn.model_selection import cross_val_score
from sklearn.metrics import mean_squared_error, r2_score

scores = cross_val_score(model, california.data, california.target, cv=10, scoring='neg_mean_squared_error')
print('NMSE mean : {}'.format(scores.mean()))
print('NMSE std : {}'.format(scores.std()))

r2_scores = cross_val_score(model, california.data, california.target, cv=10, scoring='r2')
print('R2 scores mean : {}'.format(r2_scores.mean()))

#Out[]
NMSE mean : -0.5509524296956647
NMSE std : 0.1928858295386515
R2 scores mean : 0.5110068610523766

#In[]
print('y = ' + str(model.intercept_) + ' ')

for i, c in enumerate(model.coef_):
    print()
    print(str(c) + ' * x' + str(i))
    
#Out[]
y = -36.616310741696665 
0.4317758638891808 * x0
0.00964217100767699 * x1
-0.09741188206108871 * x2
0.5806927638866005 * x3
7.059369595195281e-09 * x4
-0.007614430045996266 * x5
-0.42123968100938536 * x6
-0.4320836864988495 * x7

#In[]
y_test_predict = model.predict(X_test)

rmse = (np.sqrt(mean_squared_error(y_test, y_test_predict)))
r2 = r2_score(y_test, y_test_predict)

print( 'RMSE : {}'.format(rmse))
print('R2 Score : {}'.format(r2))

#Out[]
RMSE : 0.7223037740611354
R2 Score : 0.610740117378534

#In[]
def plot_california_prices(expected, predicted):
    plt.figure(figsize=(8, 4))
    plt.scatter(expected, predicted)
    plt.plot([0, 5], [0, 5], '--r')
    plt.xlabel('True price ($100,000)')
    plt.ylabel('Predicted price ($100,000)')
    plt.tight_layout()
    
predicted = model.predict(X_test)
expected = y_test

plot_california_prices(expected, predicted)

#Out[]

릿지 회귀(Ridge Regression)

릿지 회귀는 선형 회귀를 개선한 선형 모델
릿지 회귀는 선형 회귀와 비슷하지만, 가중치의 절대값을 최대한 작게 만든다는 것이 다름
이러한 방법은 각각의 특성(feature)이 출력 값에 주는 영향을 최소한으로 만들도록 규제(regularization)를 거는 것
규제를 사용하면 다중공선성(multicollinearity) 문제를 방지하기 때문에 모델의 과대적합을 막을 수 있게 됨
다중공선성 문제는 두 특성이 일치에 가까울 정도로 관련성(상관관계)이 높을 경우 발생
릿지 회귀는 다음과 같은 함수를 최소화 하는 파라미터 $w$ 를 찾음

$α$ : 사용자가 지정하는 매개변수
$α$ 가 크면 규제의 효과가 커지고, $α$ 가 작으면 규제의 효과가 작아짐

보스턴 주택 가격에 대한 릿지 회귀

#In[]
from sklearn.linear_model import Ridge
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split

X, y = load_boston(return_X_y=True)    #data와 target을 분리해줌!
X_train, X_test, y_train, y_test = train_test_split(X,y)

model = Ridge(alpha=0.2)
model.fit(X_train, y_train)

#Out[]
Ridge(alpha=0.2)

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.7368424082987279
평가 데이터 점수 : 0.7444343121697423

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_boston_prices(expected, predicted)

#Out[]

릿지 회귀는 가중치에 제약을 두기 때문에 선형 회귀 모델보다 훈련 데이터 점수가 낮을 수 있음
일반화 성능은 릿지 회귀가 더 높기 때문에 평가 데이터 점수는 릿지 회귀가 더 좋음
일반화 성능에 영향을 주는 매개 변수인 $α$ 값을 조정해 보면서 릿지 회귀 분석의 성능이 어떻게 변하는지 확인 필요

캘리포니아 주택 가격에 대한 릿지 회귀

#In[]
from sklearn.datasets import fetch_california_housing

california = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)

model = Ridge(alpha=0.1)
model.fit(X_train, y_train)

#Out[]
Ridge(alpha=0.1)

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.604057267179928
평가 데이터 점수 : 0.6107536986926523

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_california_prices(expected, predicted)


#Out[]

라쏘 회귀(Lasso Regression)

선형 회귀에 규제를 적용한 또 다른 모델로 라쏘 회귀가 있음
라쏘 회귀는 릿지 회귀와 비슷하게 가중치를 0에 가깝게 만들지만, 조금 다른 방식을 사용
라쏘 회귀에서는 다음과 같은 함수를 최소화 하는 파라미터 $w$ 를 찾음

라쏘 회귀도 매개변수인 $α$ 값을 통해 규제의 강도 조절 가능

보스턴 주택 가격에 대한 라쏘 회귀

#In[]
from sklearn.linear_model import Lasso
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split

X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y)

model = Lasso(alpha=0.003)
model.fit(X_train, y_train)

#Out[]
Lasso(alpha=0.003)

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.7272293998519503
평가 데이터 점수 : 0.771712660021631

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_boston_prices(expected, predicted)

#Out[]

캘리포니아 주택 가격에 대한 라쏘 회귀

#In[]
from sklearn.datasets import fetch_california_housing

california = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)

model = Lasso(alpha=0.001)
model.fit(X_train, y_train)

#Out[]
Lasso(alpha=0.001)

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.6142220442075574
평가 데이터 점수 : 0.5805641764424498

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_california_prices(expected, predicted)

#Out[]

신축망 (Elastic-Net)

신축망은 릿지 회귀와 라쏘 회귀, 두 모델의 모든 규제를 사용하는 선형 모델
두 모델의 장점을 모두 갖고 있기 때문에 좋은 성능을 보임
데이터 특성이 많거나 서로 상관 관계가 높은 특성이 존재 할 때 위의 두 모델보다 좋은 성능을 보여 줌
신축망은 다음과 같은 함수를 최소화 하는 파라미터 $w$ 를 찾음

$α$ : 규제의 강도를 조절하는 매개변수
$ρ$ : 라쏘 규제와 릿지 규제 사이의 가중치를 조절하는 매개변수

보스턴 주택 가격에 대한 신축망

#In[]
from sklearn.linear_model import ElasticNet
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split

X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y)

model = ElasticNet(alpha=0.01, l1_ratio=0.5)
model.fit(X_train, y_train)

#Out[]
ElasticNet(alpha=0.01)

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.7267947849019141
평가 데이터 점수 : 0.7183794503068747

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_boston_prices(expected, predicted)

#Out[]

캘리포니아 주택 가격에 대한 신축망

#In[]
from sklearn.linear_model import ElasticNet
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split

california = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)

model = ElasticNet(alpha=0.01, l1_ratio=0.5)
model.fit(X_train, y_train)

#Out[]
ElasticNet(alpha=0.01)

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.6020991031939832
평가 데이터 점수 : 0.6116388975222378

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_california_prices(expected, predicted)

#Out[]

직교 정합 추구 (Orthogonal Matching Pursuit)

직교 정합 추구 방법은 모델에 존재하는 가중치 벡터에 특별한 제약을 거는 방법
직교 정합 추구 방법은 다음을 만족하는 파라미터 $w$ 를 찾는것이 목표

$| | w | |_{0}$ : 가중치 벡터 $w$ 에서 0이 아닌 값의 개수

직교 정합 추구 방법은 가중치 벡터 $w$ 에서 0이 아닌 값이 $k$ 개 이하가 되도록 훈련됨
이러한 방법은 모델이 필요 없는 데이터 특성을 훈련 과정에서 자동으로 제거 하도록 만들 수 있음

보스턴 주택 가격에 대한 직교 정합 추구

#In[]
from sklearn.linear_model import OrthogonalMatchingPursuit
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split

X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X,y)

model = OrthogonalMatchingPursuit(n_nonzero_coefs=7)
model.fit(X_train, y_train)

#Out[]
OrthogonalMatchingPursuit(n_nonzero_coefs=7)

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.7067701687499545
평가 데이터 점수 : 0.7647457085035291

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_boston_prices(expected, predicted)

#Out[]

#In[1]
model = OrthogonalMatchingPursuit(tol=1.)
model.fit(X_train, y_train)

#Out[1]
OrthogonalMatchingPursuit(tol=1.0)

#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점 수 : {}".format(model.score(X_test, y_test)))

#Out[2]
학습 데이터 점수 : 0.7255197300235632
평가 데이터 점수 : 0.7831647013824865

#In[3]
predicted = model.predict(X_test)
expected = y_test

plot_boston_prices(expected, predicted)

#Out[3]

캘리포니아 주택 가격에 대한 직교 정합 추구

#In[]
from sklearn.linear_model import OrthogonalMatchingPursuit
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split

california = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)

model = OrthogonalMatchingPursuit(n_nonzero_coefs=7)
model.fit(X_train, y_train)

#Out[]
OrthogonalMatchingPursuit(n_nonzero_coefs=7)

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점 수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.6043415390059861
평가 데이터 점 수 : 0.6097795468666676

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_california_prices(expected, predicted)

#Out[]

#In[1]
model = OrthogonalMatchingPursuit(tol=1.)
model.fit(X_train, y_train)

#Out[1]
OrthogonalMatchingPursuit(tol=1.0)

#In[2]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[2]
학습 데이터 점수 : 0.6043682122857658
평가 데이터 점수 : 0.6097528736622835

#In[3]
predicted = model.predict(X_test)
expected = y_test

plot_california_prices(expected, predicted)

#Out[3]

다항 회귀 (Polynomial Regression)

입력 데이터를 비선형 변환 후 사용하는 방법
모델 자체는 선형 모델

차수가 높아질수록 더 복잡한 데이터 학습 가능

보스턴 주택 가격에 대한 다항 회귀

#In[]
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_boston

X, y = load_boston(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=123) #고정된 형태

#In[]
model = make_pipeline(
        PolynomialFeatures(degree=2),
        StandardScaler(),
        LinearRegression())

model.fit(X_train, y_train)

#Out[]
Pipeline(steps=[('polynomialfeatures', PolynomialFeatures()),
                ('standardscaler', StandardScaler()),
                ('linearregression', LinearRegression())])

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.9346787783950696
평가 데이터 점수 : 0.825786471800239

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_boston_prices(expected, predicted)

#Out[]

캘리포니아 주택 가격에 대한 다항 회귀

#In[]
from sklearn.datasets import fetch_california_housing

california = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(california.data, california.target, test_size=0.3)

model = make_pipeline(
        PolynomialFeatures(degree=2),
        StandardScaler(),
        LinearRegression())

model.fit(X_train, y_train)

#Out[]
Pipeline(steps=[('polynomialfeatures', PolynomialFeatures()),
                ('standardscaler', StandardScaler()),
                ('linearregression', LinearRegression())])

#In[]
print("학습 데이터 점수 : {}".format(model.score(X_train, y_train)))
print("평가 데이터 점수 : {}".format(model.score(X_test, y_test)))

#Out[]
학습 데이터 점수 : 0.6846989126772143
평가 데이터 점수 : 0.6705076858975946

#In[]
predicted = model.predict(X_test)
expected = y_test

plot_california_prices(expected, predicted)

#Out[]

'Youtube > 머신러닝' 카테고리의 다른 글

[머신러닝] #6 최근접 이웃(K Nearest Neighbor) (0)	2021.12.27
[머신러닝] #5 서포트 벡터 머신 (0)	2021.12.22
[머신러닝] #4 로지스틱회귀 (0)	2021.12.21
[머신러닝] #2 Scikits-learn (0)	2021.12.20
[머신러닝] #1 Machine Learning 개념 (0)	2021.12.20

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

Changhyoni_developer

[머신러닝] #3 선형 모델 Linear Models

선형 모델(Linear Models)

선형 회귀(Linear Regression)

보스턴 주택 가격 데이터

보스턴 주택 가격에 대한 선형 회귀

캘리포니아 주택 가격 데이터

캘리포니아 주택 가격에 대한 선형 회귀

릿지 회귀(Ridge Regression)

보스턴 주택 가격에 대한 릿지 회귀

캘리포니아 주택 가격에 대한 릿지 회귀

라쏘 회귀(Lasso Regression)

보스턴 주택 가격에 대한 라쏘 회귀

캘리포니아 주택 가격에 대한 라쏘 회귀

신축망 (Elastic-Net)

보스턴 주택 가격에 대한 신축망

캘리포니아 주택 가격에 대한 신축망

직교 정합 추구 (Orthogonal Matching Pursuit)

보스턴 주택 가격에 대한 직교 정합 추구

캘리포니아 주택 가격에 대한 직교 정합 추구

다항 회귀 (Polynomial Regression)

보스턴 주택 가격에 대한 다항 회귀

캘리포니아 주택 가격에 대한 다항 회귀

'Youtube > 머신러닝' 카테고리의 다른 글

+ Recent posts

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역