
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

np.random.seed(0)
# y = 4x + 6을 근사할거임
X = 2 * np.random.rand(100,1)# rand => 0 ~ 1 사이의 균일 분포에서 난수 matrix array생성 ( m * n 크기)
y = 6 + 4 * X + np.random.randn(100,1) # randn => 가우시안 표준 정규 분포에서 난수 matrix array생성 ( m * n 크기)

plt.scatter(X,y)
plt.show()
# X, y 모두 array로 1개의 column이라고 생각하면 될듯


# 비용 함수 정의하기 ( RSS )
# 1 / N 시그마 1부터 N 까지 (실제값 - 예측값) ^2
def get_cost(y, y_pred):
    N = len(y)
    cost = np.sum(np.square(y - y_pred)) / N
    return cost


# 경사하강법을 구현
# w1, w0을 0으로 초기화한 뒤 iters 개수만큼 반복하면서 w1과 w0을 업데이트 ( 편미분 적용 )

# w1, w0을 업데이트할 w1_update, w0_update 반환
def get_weight_updates(w1, w0, X, y, learning_rate = 0.01):
    N = len(y)
    # 먼저 w1_update, w0_update를 각각 w1, w0의 shape와 동일한 크기를 가진 0값으로 초기화 -> 미리 만드는 이유??
    w1_update = np.zeros_like(w1) # n * 1
    w0_update = np.zeros_like(w0) # n * 1
    # 예측 배열 계산하고 예측과 실제 값의 차이 계산
    y_pred = np.dot(X, w1.T) + w0 # 예측 값 n*1행렬 dot 1*n 행렬 -> n * n 행렬 ( X값이 1 ~ n, 각각의 가중치가 1 ~ n)
    diff = y - y_pred # n*1행렬 - n*n행렬?? -> 자동으로 n*1행렬을 n*n 행렬로 확장해서 -를 계산해준다!! ( n * n 행렬)
    
    # w0_update를 dot 행렬 연산으로 구하기 위해 모두 1값을 가진 행렬 생성
    w0_factors = np.ones((N, 1))
    
    # w1과 w0을 업데이트할 w1_update와 w0_update 계산
    w1_update = -(2/N)*learning_rate*(np.dot(X.T, diff)) # 1 * n 행렬 dot n * n 행렬
    w0_update = -(2/N)*learning_rate*(np.dot(w0_factors.T, diff)) # 1 * n 행렬 dot n * n 행렬 -> 1 * n 행렬 
    
    return w1_update, w0_update # 1 * n 행렬


# n*1행렬 - n*n행렬? 예시로 확인
y[0]

array([9.22535819])


np.dot(X,X.T)[0]

array([1.20478505, 1.57002233, 1.32321872, 1.196157  , 0.9300299 ,
       1.41790165, 0.96061508, 1.95766826, 2.11548454, 0.84175153,
       1.73803757, 1.1610587 , 1.2470021 , 2.03191974, 0.15594219,
       0.19127095, 0.04438452, 1.82781206, 1.70825173, 1.90989766,
       2.14831585, 1.75435605, 1.01306442, 1.71345981, 0.25964241,
       1.40478919, 0.31469688, 2.07378823, 1.14558962, 0.91028829,
       0.58076677, 1.69963962, 1.00136585, 1.24785691, 0.04124838,
       1.35586681, 1.34370559, 1.35432683, 2.07176676, 1.49676875,
       0.78921116, 0.95939615, 1.53147768, 0.13221021, 1.46372231,
       1.47222048, 0.46184316, 0.28302597, 0.69244535, 0.79843753,
       1.25172675, 0.96284173, 2.16973164, 0.22401428, 0.45853754,
       0.35411537, 1.43373867, 0.55603941, 1.0236706 , 0.53657626,
       0.34897862, 0.24230147, 1.44081017, 0.30334668, 0.43154822,
       0.80944541, 1.80228868, 0.21316197, 1.83950192, 0.21096042,
       2.14357656, 1.02880843, 2.1442387 , 1.32778956, 1.62287134,
       0.08602716, 0.62083312, 0.26386198, 0.65010296, 0.2606375 ,
       0.69805385, 0.9094125 , 0.14082005, 1.5201522 , 1.24383412,
       0.58259735, 1.14866239, 0.20622328, 1.26434886, 2.04004121,
       0.69933977, 1.46513532, 0.28932979, 1.57252017, 0.63531989,
       0.40215157, 1.28754488, 0.04414117, 1.81973393, 0.01030776])


(y - np.dot(X,X.T))[0]

array([8.02057314, 7.65533586, 7.90213947, 8.0292012 , 8.29532829,
       7.80745655, 8.26474311, 7.26768993, 7.10987365, 8.38360666,
       7.48732062, 8.06429949, 7.97835609, 7.19343845, 9.069416  ,
       9.03408725, 9.18097367, 7.39754613, 7.51710646, 7.31546053,
       7.07704235, 7.47100214, 8.21229377, 7.51189838, 8.96571578,
       7.820569  , 8.91066131, 7.15156996, 8.07976857, 8.3150699 ,
       8.64459142, 7.52571857, 8.22399234, 7.97750128, 9.18410981,
       7.86949139, 7.8816526 , 7.87103136, 7.15359143, 7.72858944,
       8.43614703, 8.26596204, 7.69388051, 9.09314798, 7.76163588,
       7.75313771, 8.76351503, 8.94233222, 8.53291284, 8.42692066,
       7.97363144, 8.26251646, 7.05562655, 9.00134391, 8.76682065,
       8.87124282, 7.79161952, 8.66931878, 8.20168759, 8.68878193,
       8.87637957, 8.98305672, 7.78454802, 8.92201151, 8.79380997,
       8.41591278, 7.42306951, 9.01219623, 7.38585627, 9.01439777,
       7.08178163, 8.19654976, 7.08111949, 7.89756863, 7.60248685,
       9.13933103, 8.60452507, 8.96149621, 8.57525523, 8.96472069,
       8.52730434, 8.31594569, 9.08453814, 7.70520599, 7.98152407,
       8.64276084, 8.0766958 , 9.01913491, 7.96100933, 7.18531698,
       8.52601842, 7.76022287, 8.9360284 , 7.65283802, 8.5900383 ,
       8.82320662, 7.93781332, 9.18121702, 7.40562426, 9.21505043])


# 경사 하강 방식으로 업데이트를 반복적으로 수행!!

def gradient_descent_steps(X, y, iters = 10000):
    # w0과 w1를 모두 0으로 초기화
    w0 = np.zeros((1,1))
    w1 = np.zeros((1,1))
    
    # 인자로 주어진 iters만큼 반복적으로 get_weight_updates()를 호출해 업데이트
    for _ in range(iters):
        w1_update, w0_update = get_weight_updates(w1, w0, X, y, learning_rate = 0.01) # w0, w1이 1*1행렬이므로 1개의 값만 출력된다
        w1 -= w1_update
        w0 -= w0_update
        
    return w1, w0


w1, w0 = gradient_descent_steps(X, y, iters = 1000)

print("w1 : ", round(w1[0,0],3), ", w0 : ", round(w0[0,0],3))

y_pred = w1[0,0] * X + w0
print('Gradient Descent Total Cost:{0:.4f}'.format(get_cost(y,y_pred)))

w1 :  4.022 , w0 :  6.162
Gradient Descent Total Cost:0.9935


# 회귀선 그리기
plt.scatter(X,y)
plt.plot(X, y_pred)
plt.show()


# (미니 배치) 확률적 경사 하강법

def stochastic_gradient_descent_steps(X, y, batch_size = 10, iters = 1000):
    w0 = np.zeros((1,1))
    w1 = np.zeros((1,1))
    prev_cost = 100000
    iter_index = 0
    
    for ind in range(iters):
        np.random.seed(ind)
        # 전체 X,y 데이터에서 랜덤하게 batch_size만큼 데이터를 추출해 sample 값으로 저장
        stochastic_random_index = np.random.permutation(X.shape[0]) # permutation = array를 복사해서 셔플 ( Shuffle은 해당 array)
        sample_X = X[stochastic_random_index[0:batch_size]]
        sample_y = y[stochastic_random_index[0:batch_size]] # 랜덤으로 섞어서 batch_size만큼의 행을 위에서부터 선택
        
        # sample 사이즈로 X, y선택
        w1_update, w0_update = get_weight_updates(w1, w0, sample_X, sample_y, learning_rate = 0.01)
        w1 -= w1_update
        w0 -= w0_update
        
    return w1, w0


w1, w0 = stochastic_gradient_descent_steps(X, y, iters = 1000)

print("w1 : ", round(w1[0,0],3), ", w0 : ", round(w0[0,0],3))

y_pred = w1[0,0] * X + w0
print('Gradient Descent Total Cost:{0:.4f}'.format(get_cost(y,y_pred)))

w1 :  4.028 , w0 :  6.156
Gradient Descent Total Cost:0.9937


import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from scipy import stats
from sklearn.datasets import load_boston
%matplotlib inline

# boston 데이터 세트 로드
boston = load_boston()

# boston 데이터 세트 DataFrame 변환
bostonDF = pd.DataFrame(boston.data, columns = boston.feature_names)

# boston 데이터 세트의 target 배열은 주택 가격. 이를 Price 칼럼으로 DataFrame에 추가함
bostonDF['PRICE'] = boston.target
print('Boston 데이터 세트 크기 : ', bostonDF.shape)
bostonDF.head()

Boston 데이터 세트 크기 :  (506, 14)


# regplot() : X, Y 산점도와 함께 선형 회귀 직선을 그려준다. 
# 2개의 행과 4개의 열을 가진 subplots를 이용. axs는 4*2개의 ax를 가짐

fig, axs = plt.subplots(figsize = (16, 8), ncols = 4, nrows = 2)
lm_features = ['RM','ZN','INDUS','NOX','AGE','PTRATIO','LSTAT','RAD']

for i , feature in enumerate(lm_features):
    row = int(i/4)
    col = i%4
    # regplot을 이용해 산점도와 선형 회귀 직선을 함께 표현
    sns.regplot(x=feature , y='PRICE',data=bostonDF , ax=axs[row][col])


from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error , r2_score

y_target = bostonDF['PRICE']
X_data = bostonDF.drop(['PRICE'],axis=1,inplace=False)

X_train , X_test , y_train , y_test = train_test_split(X_data , y_target ,test_size=0.3, random_state=156)

# Linear Regression OLS로 학습/예측/평가 수행
lr = LinearRegression()
lr.fit(X_train ,y_train)
y_preds = lr.predict(X_test)
mse = mean_squared_error(y_test, y_preds)
rmse = np.sqrt(mse)

print('MSE : {0:.3f} , RMSE : {1:.3F}'.format(mse , rmse))
print('Variance score : {0:.3f}'.format(r2_score(y_test, y_preds)))

MSE : 17.297 , RMSE : 4.159
Variance score : 0.757


# LinearRegression으로 생성한 주택가격 모델의 절편과 회귀 계수
print('절편 값 : ', lr.intercept_)
print('회귀 계수값 :', np.round(lr.coef_, 1))

절편 값 :  40.995595172164315
회귀 계수값 : [ -0.1   0.1   0.    3.  -19.8   3.4   0.   -1.7   0.4  -0.   -0.9   0.
  -0.6]


# coef_ 속성이 회귀 계수 값만 가지고 있기 때문에 회귀 계수 값으로 다시 매핑
# 회귀 계수를 큰 값 순으로 정렬하기 위해 Series로 생성. index가 컬럼명에 유의
coeff = pd.Series(data=np.round(lr.coef_, 1), index=X_data.columns )
coeff.sort_values(ascending=False)

RM          3.4
CHAS        3.0
RAD         0.4
ZN          0.1
INDUS       0.0
AGE         0.0
TAX        -0.0
B           0.0
CRIM       -0.1
LSTAT      -0.6
PTRATIO    -0.9
DIS        -1.7
NOX       -19.8
dtype: float64


from sklearn.model_selection import cross_val_score

y_target = bostonDF['PRICE']
X_data = bostonDF.drop(['PRICE'],axis=1,inplace=False)
lr = LinearRegression()

# cross_val_score( )로 5 Fold 셋으로 MSE 를 구한 뒤 이를 기반으로 다시  RMSE 구함. 
neg_mse_scores = cross_val_score(lr, X_data, y_target, scoring="neg_mean_squared_error", cv = 5)
# neg_mse_scores은 음수값이 반환
rmse_scores  = np.sqrt(-1 * neg_mse_scores)
avg_rmse = np.mean(rmse_scores)

# cross_val_score(scoring="neg_mean_squared_error")로 반환된 값은 모두 음수 
print(' 5 folds 의 개별 Negative MSE scores: ', np.round(neg_mse_scores, 2))
print(' 5 folds 의 개별 RMSE scores : ', np.round(rmse_scores, 2))
print(' 5 folds 의 평균 RMSE : {0:.3f} '.format(avg_rmse))

 5 folds 의 개별 Negative MSE scores:  [-12.46 -26.05 -33.07 -80.76 -33.31]
 5 folds 의 개별 RMSE scores :  [3.53 5.1  5.75 8.99 5.77]
 5 folds 의 평균 RMSE : 5.829


from sklearn.preprocessing import PolynomialFeatures
import numpy as np

# 다항식으로 변환한 단항식 생성
X = np.arange(4).reshape(2,2)
print('일차 단항식 계수 피처 \n', X)

# degree = 2 인 2차 다항식으로 변환
poly = PolynomialFeatures(degree = 2)
poly.fit(X)
poly_ftr = poly.transform(X)
print('변환된 2차 다항식 계수 피처 : \n', poly_ftr)

일차 단항식 계수 피처 
 [[0 1]
 [2 3]]
변환된 2차 다항식 계수 피처 : 
 [[1. 0. 1. 0. 0. 1.]
 [1. 2. 3. 4. 6. 9.]]


def polynomial_func(X):
    y = 1 + 2*X[:,0] + 3*X[:,0]**2 + 4*X[:,1]**3
    return y

X = np.arange(4).reshape(2,2)
print('일차 단항식 계수 피처 \n', X)

y = polynomial_func(X)
print('삼차 다항식 결정값 : \n', y)

일차 단항식 계수 피처 
 [[0 1]
 [2 3]]
삼차 다항식 결정값 : 
 [  5 125]


from sklearn.linear_model import LinearRegression

# 3차 다항식변환
poly_ftr = PolynomialFeatures(degree = 3).fit_transform(X) # 단항 계수 피처 -> 3차 다항계수로
print('3차 다항식 계수 feature : \n', poly_ftr)

# Linear Regression에 3차 다항식 계수 feature와 3차 다항식 결정값으로 학습 후 회귀 계수 확인
model = LinearRegression()
model.fit(poly_ftr, y)
print('Polynomial 회귀계수 \n', np.round(model.coef_, 2)) # 원래 다항식에 근사하고 있다
print('Polynomial 회귀 Shape', model.coef_.shape)

3차 다항식 계수 feature : 
 [[ 1.  0.  1.  0.  0.  1.  0.  0.  0.  1.]
 [ 1.  2.  3.  4.  6.  9.  8. 12. 18. 27.]]
Polynomial 회귀계수 
 [0.   0.18 0.18 0.36 0.54 0.72 0.72 1.08 1.62 2.34]
Polynomial 회귀 Shape (10,)


from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline
import numpy as np

def polynomial_func(X):
    y = 1 + 2*X[:,0] + 3*X[:,0]**2 + 4*X[:,1]**3
    return y

# Pipeline 객체로 Streamline하게 Polynomial Feature 변환과 Linear Regression을 연결
model = Pipeline([('poly', PolynomialFeatures(degree = 3)), ('linear', LinearRegression())])
X = np.arange(4).reshape(2,2)
y = polynomial_func(X)

model = model.fit(X, y)

print('Polynomial 회귀 계수 \n', np.round(model.named_steps['linear'].coef_, 2))

Polynomial 회귀 계수 
 [0.   0.18 0.18 0.36 0.54 0.72 0.72 1.08 1.62 2.34]


import numpy as np 
import matplotlib.pyplot as plt 
from sklearn.pipeline import Pipeline 
from sklearn.preprocessing import PolynomialFeatures 
from sklearn.linear_model import LinearRegression 
from sklearn.model_selection import cross_val_score
%matplotlib inline

#  임의의 값으로 구성된 X의 값에 대해 코사인 변환 값을 반환
def true_cos(X): 
    return np.cos(1.5 * np.pi * X)

# X는 0 ~ 1까지 30개의 임의의 값을 순서대로 샘플링한 데이터
np.random.seed(0)
n_samples = 30 
X = np.sort(np.random.rand(n_samples))

# y값은 true_cos에 약간의 노이즈 변동 값을 더한 값
y = true_cos(X) + np.random.randn(n_samples) * 0.1


# 다항 회귀의 차수를 변화시키면서 그에 따른 회귀 예측 곡선과 예측 정확도를 비교할 것!!

plt.figure(figsize=(14, 5))
degrees = [1, 4, 15]

# 다항 회귀의 차수(degree)를 1, 4, 15로 각각 변화시키면서 비교합니다. 
for i in range(len(degrees)):
    ax = plt.subplot(1, len(degrees), i + 1)
    plt.setp(ax, xticks=(), yticks=()) # setp() : 선 두께, 색깔 등 좀 더 다양한 조정을 할 수 있음 
    
    # 개별 degree별로 Polynomial 변환합니다. 
    polynomial_features = PolynomialFeatures(degree = degrees[i], include_bias=False)
    linear_regression = LinearRegression()
    pipeline = Pipeline([("polynomial_features", polynomial_features),
                         ("linear_regression", linear_regression)])
    pipeline.fit(X.reshape(-1, 1), y)
    
    # 교차 검증으로 다항 회귀를 평가합니다. 
    scores = cross_val_score(pipeline, X.reshape(-1,1), y,scoring="neg_mean_squared_error", cv=10)
     # Pipeline을 구성하는 세부 객체를 접근하는 named_steps['객체명']을 이용해 회귀계수 추출
    coefficients = pipeline.named_steps['linear_regression'].coef_ # coef_ : 회귀 계수
    print('\nDegree {0} 회귀 계수는 {1} 입니다.'.format(degrees[i], np.round(coefficients),2))
    print('Degree {0} MSE 는 {1} 입니다.'.format(degrees[i] , -1*np.mean(scores)))
    
    # 0 부터 1까지 테스트 데이터 세트를 100개로 나눠 예측을 수행합니다. 
    # 테스트 데이터 세트에 회귀 예측을 수행하고 예측 곡선과 실제 곡선을 그려서 비교합니다.  
    X_test = np.linspace(0, 1, 100)
    # 예측값 곡선
    plt.plot(X_test, pipeline.predict(X_test[:, np.newaxis]), label="Model")  # newaxis : numpy array의 차원을 늘려준다
    # 실제 값 곡선
    plt.plot(X_test, true_cos(X_test), '--', label="True function")
    plt.scatter(X, y, edgecolor='b', s=20, label="Samples")
    
    plt.xlabel("x"); plt.ylabel("y"); plt.xlim((0, 1)); plt.ylim((-2, 2)); plt.legend(loc="best")
    plt.title("Degree {}\nMSE = {:.2e}(+/- {:.2e})".format(degrees[i], -scores.mean(), scores.std()))

plt.show()

Degree 1 회귀 계수는 [-2.] 입니다.
Degree 1 MSE 는 0.40772896250986845 입니다.

Degree 4 회귀 계수는 [  0. -18.  24.  -7.] 입니다.
Degree 4 MSE 는 0.0432087498723184 입니다.

Degree 15 회귀 계수는 [-2.98300000e+03  1.03900000e+05 -1.87417000e+06  2.03717200e+07
 -1.44874017e+08  7.09319141e+08 -2.47067172e+09  6.24564702e+09
 -1.15677216e+10  1.56895933e+10 -1.54007040e+10  1.06457993e+10
 -4.91381016e+09  1.35920642e+09 -1.70382078e+08] 입니다.
Degree 15 MSE 는 182581084.8263125 입니다.


# 업로드용 창 맞추기

from IPython.core.display import display, HTML

display(HTML("<style>.container { width:90% !important; }</style>"))

	CRIM	ZN	INDUS	NOX	RM	AGE	DIS	RAD	TAX	PTRATIO	B	LSTAT	PRICE
0	0.00632	18.0	2.31	0.538	6.575	65.2	4.0900	1.0	296.0	15.3	396.90	4.98	24.0
1	0.02731	0.0	7.07	0.469	6.421	78.9	4.9671	2.0	242.0	17.8	396.90	9.14	21.6
2	0.02729	0.0	7.07	0.469	7.185	61.1	4.9671	2.0	242.0	17.8	392.83	4.03	34.7
3	0.03237	0.0	2.18	0.458	6.998	45.8	6.0622	3.0	222.0	18.7	394.63	2.94	33.4
4	0.06905	0.0	2.18	0.458	7.147	54.2	6.0622	3.0	222.0	18.7	396.90	5.33	36.2

티스토리

[파이썬 머신러닝 완벽 가이드] 5장. 회귀 - 1

[파이썬 머신러닝 완벽 가이드] 5장. 회귀 - 1

<파이썬 머신러닝 완벽 가이드>¶

회귀 1 ( p290 ~ p319)¶

1. 회귀란?¶

2. 단순 선형 회귀를 통한 회귀 이해¶

3. 경사하강법¶

4. 선형 회귀를 이용한 보스턴 주택 가격 예측¶

5. 다항 회귀와 과적합 / 과소적합 이해¶