728x90

확률적 경사 하강법, 손실 함수, 에포크

 

점진적 학습(온라인 학습)

 - 한번에 수많은 data를 모두 memory에 넣고 학습을 할 수 없으니 점진적으로 학습이 필요.

 - 또는 학습할 data가 시간이 지나면서 계속 추가되는 경우

 

확률적 경사 하강법 : Stochastic  Gradient Descent

 - 대표적인 점진적 학습 알고리즘

 - 훈련세트에서 하나씩 샘플을 꺼내 손실함수의 경사를 따라 최적의 모델을 찾는 알고리즘

미니배치 경사 하강법 : Minibatch Gradient Descent

 - 여러 개씩 꺼내 사용

배치 경사 하강법 : Batch Gradient Descent

 - 모두 꺼내 사용

점진적 학습 과정

손실함수: Loss Function, 비용 함수 : Cost Function

 - 손실 함수는 샘플 하나에 대한 손실을 정의, 비용 함수는 훈련 세트에 있는 모든 샘플에 대한 소실 함수의 합을 말하지만 엄격히 구분하지 않고 섞어 사용하는 경우가 많음

 - 확률적 경사 하강법이 최적화할 대상

 - 손실 함수는 오차가 얼마나 큰 지 측정하는 기준으로 함수의 값이 작을수록 좋다.

 - 손실 함수는 미분이 가능해야 한다

 

로지스틱 손실함수: Logistic Loss Function

이진 크로스엔트로비 손실 함수: Binary Cross-entropy Loss Function

크로스엔트로비 손실 함수: Cross-entropy Loss Function

 - 로지스틱 손실 함수를 사용하면 로지스틱 회귀 모델이 만들어진다.

 

회귀에서 사용하는 손실 함수:

평균 절댓값 오차

 - 타깃에서 예측을 뺀 절댓값을 모든 샘플에 평균한 값

평균 제곱 오차: Mean Squared Error

 - 타깃에서 예측을 뺀 값을 제곱한 다음 모든 샘플에 평균한 값

 

에포크

 - 확률적 경사 하강법에서 전체 샘플을 모두 사용하는 한 번 반복을 의미

 - 확률적 경사 하강법을 사용한 모델은 에프크 횟수에 따라 과소적합/과대적합이 될 수 있다.

 - 에포크가 너무 적으로면 과소, 많으면 과대 적합

 - 과대적합이 되기 전에 훈련을 멈추는 것이 조기종료(early stopping)

 

힌지 손실: hinge loss

 - SGDClassifier의 loss parameter의 기본 값, 서포트 백터 머신(Support vector machine) 알고리즘을 위한 손실 함수

 

SGDClassifier

import pandas as pd
fish = pd.read_csv('https://bit.ly/fish_csv_data')

fish_input = fish[['Weight','Length','Diagonal','Height','Width']].to_numpy()
fish_target = fish['Species'].to_numpy()

from sklearn.model_selection import train_test_split

train_input, test_input, train_target, test_target = train_test_split(
    fish_input, fish_target, random_state=42)

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
ss.fit(train_input)
train_scaled = ss.transform(train_input)
test_scaled = ss.transform(test_input)

from sklearn.linear_model import SGDClassifier
sc = SGDClassifier(loss='log', max_iter=35, random_state=42)
sc.fit(train_scaled, train_target)

print(sc.score(train_scaled, train_target))
print(sc.score(test_scaled, test_target))

0.8403361344537815

0.8

sc.partial_fit(train_scaled, train_target)

print(sc.score(train_scaled, train_target))
print(sc.score(test_scaled, test_target))

0.907563025210084

0.925

에포크와 과대/과소적합

import numpy as np

sc = SGDClassifier(loss='log', random_state=42)

train_score = []
test_score = []

classes = np.unique(train_target)

# python에서 _ 변수는 다른 곳에서 사용하지는 않고 버리는 값을 저장하는데 쓴다
for _ in range(0, 300):
    sc.partial_fit(train_scaled, train_target, classes=classes)
    
    train_score.append(sc.score(train_scaled, train_target))
    test_score.append(sc.score(test_scaled, test_target))

import matplotlib.pyplot as plt

plt.plot(train_score)
plt.plot(test_score)
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.show()

sc = SGDClassifier(loss='log', max_iter=100, tol=None, random_state=42)
sc.fit(train_scaled, train_target)

print(sc.score(train_scaled, train_target))
print(sc.score(test_scaled, test_target))

0.957983193277311

0.925

sc = SGDClassifier(loss='hinge', max_iter=100, tol=None, random_state=42)
sc.fit(train_scaled, train_target)

print(sc.score(train_scaled, train_target))
print(sc.score(test_scaled, test_target))

0.9495798319327731

0.925

728x90
728x90

회귀(Regression) : class중 하로 분류하는 것이 아니라 임의의 어떤 숫자를 예측하는 문제

 

k-최근접 이웃 분류 Vs 회귀

분류 : 최근접 이웃 중에 가장 많은 class와 같은 것으로 분류

회귀 : 최근접 이웃의 평균으로 목표 숫자 예측

 

결정계수(R^2) : coefficient of determination

회귀 모델에서 예측의 적합도를 0과 1 사이의 값으로 계산, 1에 가까울수도 완벽

R^2 = 1 - (타깃 - 예측)^2 / (타깃 - 평균)^2

 

과대적합(Overfitting) Vs 과소적합(Underfitting)

과대적합은 훈련세트에 너무 심하게 맞춰져 있어 test점수가 낮아지는 현상

과소적합은 훈련세트에 제대로 맞지 않아 훈련세트/테스트세트 둘다 점수가 낮거나 심하면 테스트세트보다 훈련테스의 점수가 낮음

 

선형회귀 : Linear regression

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

 

가중치(or 계수) : weight(or Coefficient)

선형 회귀가 학습한 직선의 기울기

 

다중 회귀 : Multiple regression

여러 개의 특성을 사용한 선형 회귀(다차원 그래프가 만들어진다)

 

transforemer(변환기)

사이킷런의 전처리용 class : 특성을 만들거나 target data없이 input data를 변환

 

릿지 회귀(Ridge regression)

규제가 있는 선형 회귀 모델 중 하나, alpha로 규제의 강도 조절, alpha가 클수록 규제 강도가 세짐(클수록 과대적합의 가능성 커짐)

라쏘회귀(Lasso regression)

릿지와 달리 계수 값을 아예 0으로 만들 수도 있음

 

Hyperparameter

머신러닝 모델이 학습할 수 없고 사람이 지정하는 파라미터

728x90
728x90

로지스틱 회귀(Logistic regression) : 선형 방정식을 사용한 분류 알고리즘, 선형회귀와 달리 sigmoid/softmax function을 사용하여 class 확률을 출력 가능

다중 분류 : target class가 2개 이상인 분류

Sigmoid function : 선형방정식의 출력을 0과 1 사이의 값으로 압축하여 이진 분류를 위해 사용

Softmax : 다중 분류에서 여러 선형 방정식의 출력 결과를 정규화하여 합이 1이 되도록 만든다.

 

import pandas as pd

fish = pd.read_csv('https://bit.ly/fish_csv_data')
fish.head()

print(pd.unique(fish['Species']))

fish_input = fish[['Weight','Length','Diagonal','Height','Width']].to_numpy()
print(fish_input[:5])

unique한 species종류를 확인하고 input data의 양이 많으니 5개만 잘 들어갔나 확인해보자
['Bream' 'Roach' 'Whitefish' 'Parkki' 'Perch' 'Pike' 'Smelt']

[[242. 25.4 30. 11.52 4.02 ]

[290. 26.3 31.2 12.48 4.3056]

[340. 26.5 31.1 12.3778 4.6961]

[363. 29. 33.5 12.73 4.4555]

[430. 29. 34. 12.444 5.134 ]]

 

fish_target = fish['Species'].to_numpy()

from sklearn.model_selection import train_test_split

train_input, test_input, train_target, test_target = train_test_split(
    fish_input, fish_target, random_state=42)

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
ss.fit(train_input)
train_scaled = ss.transform(train_input)
test_scaled = ss.transform(test_input)

<< 여기까지 이번 장을 위한 data 준비

 

이번 장은 주어진 data를 가지고 어느 분류에 해당할 지 확률을 구하는 내용이다.

 

k-최근접 이웃 분류기의 확률 예측

KNeighborsClassifier로 분류해본다. K를 3으로 두어 주변 3개의 값만 확인하도록 해본다. (단순 비교용)

from sklearn.neighbors import KNeighborsClassifier

kn = KNeighborsClassifier(n_neighbors=3)
kn.fit(train_scaled, train_target)

print(kn.score(train_scaled, train_target))
print(kn.score(test_scaled, test_target))

0.8907563025210085

0.85

print(kn.classes_)
print(kn.predict(test_scaled[:5]))

['Bream' 'Parkki' 'Perch' 'Pike' 'Roach' 'Smelt' 'Whitefish']

['Perch' 'Smelt' 'Pike' 'Perch' 'Perch']

 

import numpy as np

proba = kn.predict_proba(test_scaled[:5])
print(np.round(proba, decimals=4))

[[0. 0. 1. 0. 0. 0. 0. ]

[0. 0. 0. 0. 0. 1. 0. ]

[0. 0. 0. 1. 0. 0. 0. ]

[0. 0. 0.6667 0. 0.3333 0. 0. ]

[0. 0. 0.6667 0. 0.3333 0. 0. ]]

단순에 주변 3개의 이웃 중에 얼마의 비중으로 들어 있는가를 보여준다.

distances, indexes = kn.kneighbors(test_scaled[3:4])
print(train_target[indexes])

[['Roach' 'Perch' 'Perch']]

로지스틱 회귀

import numpy as np
import matplotlib.pyplot as plt

z = np.arange(-5, 5, 0.1)
phi = 1 / (1 + np.exp(-z))

plt.plot(z, phi)
plt.xlabel('z')
plt.ylabel('phi')
plt.show()

로지스틱 회귀로 이진 분류 수행하기

char_arr = np.array(['A', 'B', 'C', 'D', 'E'])
print(char_arr[[True, False, True, False, False]])

['A' 'C']  <<- True인 값만 표시된다.

bream_smelt_indexes = (train_target == 'Bream') | (train_target == 'Smelt')
train_bream_smelt = train_scaled[bream_smelt_indexes]
target_bream_smelt = train_target[bream_smelt_indexes]

from sklearn.linear_model import LogisticRegression

lr = LogisticRegression()
lr.fit(train_bream_smelt, target_bream_smelt)

print(lr.predict(train_bream_smelt[:5]))
print(lr.predict_proba(train_bream_smelt[:5]))

['Bream' 'Smelt' 'Bream' 'Bream' 'Bream']

[[0.99759855 0.00240145]

[0.02735183 0.97264817]

[0.99486072 0.00513928]

[0.98584202 0.01415798]

[0.99767269 0.00232731]]

두개의 값으로 예측을 했다. 이 두개의 값이 무엇인지 알아보자

print(lr.classes_)

['Bream' 'Smelt']

 5개를 예측했는데 두번째가 Smelt일 것으로 예측(양성 클래스가 Smelt)하였고,

나머지 4개는 Bream으로 예측하였다.

 

로지스틱 회귀가 학습한 계수를 확인해보자

print(lr.coef_, lr.intercept_)

[[-0.4037798 -0.57620209 -0.66280298 -1.01290277 -0.73168947]] [-2.16155132]

decisions = lr.decision_function(train_bream_smelt[:5])
print(decisions)

[-6.02927744 3.57123907 -5.26568906 -4.24321775 -6.0607117 ]

from scipy.special import expit
print(expit(decisions))

[0.00240145 0.97264817 0.00513928 0.01415798 0.00232731]

 

로지스틱 회귀로 다중 분류 수행하기

lr = LogisticRegression(C=20, max_iter=1000)
lr.fit(train_scaled, train_target)

print(lr.score(train_scaled, train_target))
print(lr.score(test_scaled, test_target))

0.9327731092436975

0.925

 

C는 기본값이 1이며 숫자가 적을수록 규제가 강하다.

max_iter는 기본값이 100이며 충분히 훈련하기 위해 값을 늘려줘야 한다.

print(lr.predict(test_scaled[:5]))

proba = lr.predict_proba(test_scaled[:5])
print(lr.classes_)
print(np.round(proba, decimals=3))

['Perch' 'Smelt' 'Pike' 'Roach' 'Perch']

['Bream'   'Parkki'    'Perch'    'Pike'        'Roach'   'Smelt'   'Whitefish']

[[0.          0.014      0.841     0.             0.136     0.007    0.003]

 [0.          0.003      0.044     0.             0.007     0.946    0. ]

 [0.          0.           0.034     0.935        0.015     0.016    0. ]

 [0.011     0.034      0.306     0.007        0.567     0.          .076]

 [0.         0.            0.904    0.002        0.089     0.002     0.001]]

생선의 종류가 7가지라 열이 7개

 

print(lr.coef_.shape, lr.intercept_.shape)

(7, 5) (7,)   <<- 선형 방정식

decision = lr.decision_function(test_scaled[:5])
print(np.round(decision, decimals=2))

[[ -6.5 1.03 5.16 -2.73 3.34 0.33 -0.63]

[-10.86 1.93 4.77 -2.4 2.98 7.84 -4.26]

[ -4.34 -6.23 3.17 6.49 2.36 2.42 -3.87]

[ -0.68 0.45 2.65 -1.19 3.26 -5.75 1.26]

[ -6.4 -1.99 5.82 -0.11 3.5 -0.11 -0.71]]

from scipy.special import softmax

proba = softmax(decision, axis=1)
print(np.round(proba, decimals=3))

[[0.      0.014      0.841      0.        0.136      0.007     0.003]

 [0.      0.003      0.044      0.        0.007      0.946     0. ]

 [0.      0.          0.034       0.935   0.015      0.016     0. ]

 [0.011 0.034      0.306      0.007    0.567     0.          0.076]

 [0.     0.           0.904      0.002    0.089     0.002     0.001]]

 

 

 

 

 

728x90
728x90

keyword : 다중회귀, 특성공학, 릿지, 라쏘, 하이퍼파라미터

multiple regression, feature engineering, Ridge, Lasso, hyperparameter

 

농어의 무게를 예측하는데 길이 정보만 사용되었다.

높이, 두께 등 다양한 값을 추가하여 예측 성공율을 높여 보자.

PolynomialFeatures Class를 사용할 것이라고 하는데....

 

다중회귀(multiple regression) : 여러개의 특성을 사용한 선형 회귀

특성공학(feature engineering) : feature engineering란 용어가 이해하기 좀 더 쉽다. 기존의 특성을 이용해 새로운 특성을 만들어내는 작업

       이번 예제에서는 '농어 길이 * 농어 높이'를 새로운 특성으로 정의했다.

Pandas : data 분석 library(dataframe 사용)

 

import pandas as pd
df = pd.read_csv('https://bit.ly/perch_csv_data')
perch_full = df.to_numpy()
print(perch_full)

[[ 8.4 2.11 1.41]
[13.7 3.53 2. ]
[15. 3.82 2.43]
[16.2 4.59 2.63]
[17.4 4.59 2.94]
[18. 5.22 3.32]

[18.7 5.2 3.12]

[19. 5.64 3.05]

....

https://bit.ly/perch_csv_data => https://raw.githubusercontent.com/rickiepark/hg-mldl/master/perch_full.csv

length, height, width
8.4 ,  2.11,  1.41
13.7,  3.53,  2.  
15. ,  3.82,  2.43
16.2,  4.59,  2.63
17.4,  4.59,  2.94
....

 

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]
     )

from sklearn.model_selection import train_test_split
#train data와 test data 생성
train_input, test_input, train_target, test_target = train_test_split(perch_full, perch_weight, random_state=42)

 

from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures()
poly.fit([[2, 3]])
print(poly.transform([[2, 3]]))

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

 

주인공이 나왔다.

fit()은 추가적인 특성을 찾아내고, transform은 값을 넣는다.

2,3을 가지고 특성을 찾았기 때문에 2,3 그리고 2^2, 3^2가 추가되고, 2+3, 2*3도 추가되었다.

그런데 1은? 절편값이라고 하는데 선형모델에서는 자동으로 추가되기 때문에 필요하지 않다고 한다.

이 값을 제거하기 위해 include_bias=False를 준다.

사이킷런에서는 자동으로 False로 해준다고 한다.

 

poly = PolynomialFeatures(include_bias=False)
poly.fit([[2, 3]])
print(poly.transform([[2, 3]]))

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

poly = PolynomialFeatures(include_bias=False)

poly.fit(train_input)
train_poly = poly.transform(train_input)
print(train_poly.shape)

(42, 9)

 

poly.get_feature_names_out()

array(['x0', 'x1', 'x2', 'x0^2', 'x0 x1', 'x0 x2', 'x1^2', 'x1 x2', 'x2^2'], dtype=object)

 

get_feature_names_out() : feature가 어떻게 구성되었는지 보여준다.

test_poly = poly.transform(test_input)

 

다중회귀 모델 훈련하기

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.9714559911594132

테스트점수

 

제곱까지의 변수만 사용하였는데 3승,4승의 항을 넣으려면 degree를 조정하면 된다.(max=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)
print(poly.get_feature_names_out())

(42, 55)

['x0' 'x1' 'x2' 'x0^2' 'x0 x1' 'x0 x2' 'x1^2' 'x1 x2' 'x2^2' 'x0^3'
 'x0^2 x1' 'x0^2 x2' 'x0 x1^2' 'x0 x1 x2' 'x0 x2^2' 'x1^3' 'x1^2 x2'
 'x1 x2^2' 'x2^3' 'x0^4' 'x0^3 x1' 'x0^3 x2' 'x0^2 x1^2' 'x0^2 x1 x2'
 'x0^2 x2^2' 'x0 x1^3' 'x0 x1^2 x2' 'x0 x1 x2^2' 'x0 x2^3' 'x1^4'
 'x1^3 x2' 'x1^2 x2^2' 'x1 x2^3' 'x2^4' 'x0^5' 'x0^4 x1' 'x0^4 x2'
 'x0^3 x1^2' 'x0^3 x1 x2' 'x0^3 x2^2' 'x0^2 x1^3' 'x0^2 x1^2 x2'
 'x0^2 x1 x2^2' 'x0^2 x2^3' 'x0 x1^4' 'x0 x1^3 x2' 'x0 x1^2 x2^2'
 'x0 x1 x2^3' 'x0 x2^4' 'x1^5' 'x1^4 x2' 'x1^3 x2^2' 'x1^2 x2^3' 'x1 x2^4'
 'x2^5']

lr.fit(train_poly, train_target)
print(lr.score(train_poly, train_target))
print(lr.score(test_poly, test_target))

0.9999999999991096

-144.40579242335605

특성의 개수가 많아 훈련 세트에서는 거의 완벽하게 학습이 되지만 과대적합으로 인해 test set에서는 형편없는 점수가 나온다.

 

규제 : 과대적합을 줄이는 방법

선형회귀 모델의 경우 계수(or 기울기)를 줄여 일반적인 모델로 만들 수 있다.

정규화

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
ss.fit(train_poly)

train_scaled = ss.transform(train_poly)
test_scaled = ss.transform(test_poly)

train set와 test set는 항상 함께!

 

Ridge : 계수를 제곱한 값을 기준으로 규제를 적용, alpha값이 클수록 규제가 심해진다.(default=1)       solver를 지정할 수 있다.(ㅊ매개변수에 최적의 모델을 찾기 위한 방법 지정       default : solver=auto       추천 : solver=sag, solver=saga    (saga는 sag의 개선버전으로 사이킷런 0.19 이후 적용)Lasso : 절댓값을 기준으로 규제를 적용

 

Ridge

from sklearn.linear_model import Ridge

ridge = Ridge()
ridge.fit(train_scaled, train_target)
print(ridge.score(train_scaled, train_target))
print(ridge.score(test_scaled, test_target))

0.9896101671037343

0.9790693977615397

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.plot(np.log10(alpha_list), train_score)
plt.plot(np.log10(alpha_list), test_score)
plt.xlabel('alpha')
plt.ylabel('R^2')
plt.show()

alpha값을 변경해가며 확인하여 train 점수와 test 점수가 가장 비슷한 alpha가 최적의 값이 된다.

그래프의 왼쪽은 훈련세트에서 점수가 높고 테스트세트에서 점수가 낮은 과대적합, 오른쪽은 둘 다 점수가 낮아지는 과소적합의 모습을 보인다.

여기에서는 0.1이 최적의 값이 되었다.

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

print(ridge.score(train_scaled, train_target))
print(ridge.score(test_scaled, test_target))

0.9903815817570366

0.9827976465386927

 

Lasso

Rigde와 동일하게 사용하고 이름을 Lasso로 바꾼다.

from sklearn.linear_model import Lasso

lasso = Lasso()
lasso.fit(train_scaled, train_target)
print(lasso.score(train_scaled, train_target))
print(lasso.score(test_scaled, test_target))

0.989789897208096

0.9800593698421883

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.plot(np.log10(alpha_list), train_score)
plt.plot(np.log10(alpha_list), test_score)
plt.xlabel('alpha')
plt.ylabel('R^2')
plt.show()

이 결과에서 최적값은 alpha=1 값이다. 즉 10^1 = 10 이다.

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

print(lasso.score(train_scaled, train_target))
print(lasso.score(test_scaled, test_target))

0.9888067471131867

0.9824470598706695

print(np.sum(lasso.coef_ == 0))

40

Lasso모델은 계속의 값을 0으로 설정할 수도 있다. 55가지 특성 중 40가지는 사용되지 않았다는 뜻이다.이 값을 이용하여 필요하지 않은 특성을 골라낼 수 있다.

728x90

+ Recent posts