[머신러닝] 과적합 및 하이퍼파라미터

 

 

 

 

 

과적합 및 하이퍼파라미터

 

1. 과적합 및 스케일링

과적합 : 과적합 또는 과대적합은 기계 학습에서 학습 데이터를 과하게 학습하는 것을 뜻한다. 일반적으로 학습 데이터는 실제 데이터의 부분 집합이므로 학습 데이터에 대해서는 오차가 감소하지만 실제 데이터에 대해서는 오차가 증가하게 된다.

1.과적합 및 스케일링.pdf

2.85MB

1.과적합 및 스케일링.html

0.37MB

1.과적합 및 스케일링.ipynb

0.08MB

 

 

2. 하이퍼 파라미터

하이퍼 파라미터 : 하이퍼 파라미터는 최적의 훈련 모델을 구현하기 위해 모델에 설정하는 변수로 학습률 ( Leraning Rate ), 에포크 수 ( 훈련 반복 횟수 ), 가중치 초기화 등을 결정할 수 있다. 이러한 하이퍼 파라미터 튜닝 기법을 적용하면 훈련 모델의 최적의 값들을 찾을 수 있다.

2.하이퍼 파라미터.pdf

3.47MB

2.하이퍼 파라미터.html

0.34MB

2.하이퍼 파라미터.ipynb

0.05MB

 

 

 

이미지가 포함되어 있으므로 pdf 로 확인할 것

 

---

 

 

과적합 및 스케일링

과대적합과 과소적합¶

과대적합(overfitting)¶

• 훈련데이터에만 잘 맞고 테스트데이터에는 낮은 정답률이 나오는 경우

과소적합(underfitting)¶

• 훈련이 제대로 이루어지지 않아 테스트 데이터보다 훈련데이터의 정답률이 낮은 경우
• 훈련, 테스트데이터 모두 정답률이 낮은 경우
• 훈련데이터의 개수가 적을 경우

---ht="" />

---

스케일링¶

• 수치형 데이터들의 값의 범위가 클 경우 사용한다.(연산 속도 증가)
  • 예를 들어 주식의 가격을 생각했을 경우 100원의 1%와 100000원의 1%를 계산하고자 한다면 같은 1%연산이지만 숫자가 클 경우 연산속도에 영향을 미치게 된다.
• 서로 다른 변수의 값 범위를 일정한 수준으로 맞추고자 하는 경우
• 대표적 스케일링 클래스는 StandardScaler, MinMaxScaler이 있다
• 사용 이유
  • 연산속도를 올릴 수 있다
  • 확률을 높일 수 있다
  • 과대, 과소적합을 조금은 해결할 수 있다
• 참고
  • 이상치가 있을 경우 범위의 차이가 커지게 되므로 이상치는 제거해야 한다
  • RandomForest는 따로 스케일링 할 필요가 없다.(tree계열은 따로 스케일 할 필요가 없다)

StandardScaler(label값은 스케일 하지 않는다)¶

• 사이킷런에서 서포트벡터머신, 선형회귀, 로지스틱 회귀에 적용하는 것이 예측 성능 향상에 중요한 요소가 된다.
• 각 특성의 평균을 0, 편차를 1로 변경하여 정규분포로 만드는 것이다
  • 편차(deviation)는 예측값과 평균의 차이

MinMaxScaler(label값은 스케일 하지 않는다)¶

• 모든 특성이 정확하게 0과 1사이에 위치하도록 데이터를 변경
• k-means, k-nearest neighbor등의 알고리즘에 좋은 성능을 보인다은 성능을 보인다

In [3]:

import pandas as pd
from sklearn.preprocessing import StandardScaler

# 가상의 영화 평점 데이터
movie = {'daum':[2,4,6,8,10], 'naver':[1,2,3,4,5]}
mv = pd.DataFrame(movie)
mv

Out[3]:

	daum	naver
0	2	1
1	4	2
2	6	3
3	8	4
4	10	5

In [13]:

# standardscaler 를 사용해서
# 두 데이터 간의 범위를 줄인다
st = StandardScaler()
scaled = st.fit_transform(mv)
mv = pd.DataFrame(data = scaled, columns=['daum', 'naver'])
mv

Out[13]:

	daum	naver
0	-1.414214e+00	-1.414214e+00
1	-7.071068e-01	-7.071068e-01
2	4.440892e-17	4.440892e-17
3	7.071068e-01	7.071068e-01
4	1.414214e+00	1.414214e+00

In [12]:

# round() : 소숫점 범위를 잘라준다
round(scaled.std(), 2)

Out[12]:

1.0

In [ ]:

In [ ]:

In [16]:

from sklearn.preprocessing import MinMaxScaler
mv = pd.DataFrame(movie)
mv

Out[16]:

	daum	naver
0	2	1
1	4	2
2	6	3
3	8	4
4	10	5

In [18]:

# MinMaxScaler 를 사용해
# 다른 두 값을 0 ~ 1 사이의 값으로
# 바꿔준다
m = MinMaxScaler()
min_max_mv = m.fit_transform(mv)
pd.DataFrame(min_max_mv, columns=['d', 'b'])

Out[18]:

	d	b
0	0.00	0.00
1	0.25	0.25
2	0.50	0.50
3	0.75	0.75
4	1.00	1.00

In [ ]:

In [ ]:

In [19]:

df = pd.read_csv("../data_set/5.스케일링/bank_train_clean.csv")
df.head()

Out[19]:

	age	duration	campaign	pdays	previous	y
0	58	261	1	-1	0	0
1	44	151	1	-1	0	0
2	33	76	1	-1	0	0
3	47	92	1	-1	0	0
4	33	198	1	-1	0	0

In [20]:

df.columns

Out[20]:

Index(['age', 'duration', 'campaign', 'pdays', 'previous', 'y'], dtype='object')

In [21]:

features = ['age', 'duration', 'campaign', 'pdays', 'previous']
label = 'y'

X, y = df[features], df[label]

In [22]:

from sklearn.model_selection import train_test_split

# 학습용 70%, 테스트용 30%
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

In [26]:

from sklearn.ensemble import RandomForestClassifier

# 머신 생성
rfc = RandomForestClassifier()

# 머신 학습
rfc.fit(X_train, y_train);

print( "학습 데이터 : ", rfc.score(X_train, y_train) )

# 학습된 머신 테스트 결과
print( "test 데이터 : ", rfc.score(X_test, y_test) )

# 학습 데이터의 결과와 테스트 결과의 차이가 커지면
# 과적합 되었다라고 말한다

학습 데이터 :  0.9923847442095617
test 데이터 :  0.8815246240047184

In [ ]:

In [ ]:

In [28]:

from sklearn.neighbors import KNeighborsClassifier

# 머신 생성
kn = KNeighborsClassifier()

# 머신 학습
kn.fit(X_train, y_train)

print( "학습 데이터 : ", kn.score(X_train, y_train) )

# 학습된 머신 테스트 결과
print( "test 데이터 : ", kn.score(X_test, y_test) )

# 학습 데이터와 test 데이터 테스트 결과의
# 차이 폭이 적으므로 좋은 알고리즘이다....

학습 데이터 :  0.9139570891395709
test 데이터 :  0.8846210557357712

In [ ]:

In [ ]:

In [30]:

# 데이터 스케일링
sc = StandardScaler()
sc.fit( X )
X2 = sc.transform( X )
X2

Out[30]:

array([[ 1.60696496,  0.0110161 , -0.56935064, -0.41145311, -0.25194037],
       [ 0.28852927, -0.41612696, -0.56935064, -0.41145311, -0.25194037],
       [-0.74738448, -0.70736086, -0.56935064, -0.41145311, -0.25194037],
       ...,
       [ 2.92540065,  3.37379688,  0.72181052,  1.43618859,  1.05047333],
       [ 1.51279098,  0.97014641,  0.39902023, -0.41145311, -0.25194037],
       [-0.37068857,  0.39932797, -0.24656035,  1.4761376 ,  4.52357654]])

In [31]:

X_train, X_test, y_train, y_test = train_test_split(X2, y, test_size=0.3)

In [35]:

# 머신 생성
rfc = RandomForestClassifier()

# 머신 학습
rfc.fit(X_train, y_train);

print( "학습 데이터 : ", rfc.score(X_train, y_train) )

# 학습된 머신 테스트 결과
print( "test 데이터 : ", rfc.score(X_test, y_test) )

# 스케일링된 데이터로 다시 테스트

학습 데이터 :  0.9919423642051379
test 데이터 :  0.8757003833677381

In [36]:

# 머신 생성
kn = KNeighborsClassifier()

# 머신 학습
kn.fit(X_train, y_train)

print( "학습 데이터 : ", kn.score(X_train, y_train) )

# 학습된 머신 테스트 결과
print( "test 데이터 : ", kn.score(X_test, y_test) )

# 스케일링된 데이터로 다시 테스트

학습 데이터 :  0.9128195405567668
test 데이터 :  0.8824830433500442

스케일링을 사용하면 과적합을 줄여줄 수도 있다¶

In [ ]:

In [ ]:

In [41]:

# fit_transform() 을 사용하여 스케일링
X2 = m.fit_transform( X )
X2

Out[41]:

array([[0.51948052, 0.05307035, 0.        , 0.        , 0.        ],
       [0.33766234, 0.03070354, 0.        , 0.        , 0.        ],
       [0.19480519, 0.01545344, 0.        , 0.        , 0.        ],
       ...,
       [0.7012987 , 0.22915819, 0.06451613, 0.21215596, 0.01090909],
       [0.50649351, 0.10329402, 0.0483871 , 0.        , 0.        ],
       [0.24675325, 0.07340382, 0.01612903, 0.21674312, 0.04      ]])

In [38]:

X_train, X_test, y_train, y_test = train_test_split(X2, y, test_size=0.3)

In [39]:

# 머신 생성
rfc = RandomForestClassifier()

# 머신 학습
rfc.fit(X_train, y_train);

print( "학습 데이터 : ", rfc.score(X_train, y_train) )

# 학습된 머신 테스트 결과
print( "test 데이터 : ", rfc.score(X_test, y_test) )

# 스케일링된 데이터로 다시 테스트

학습 데이터 :  0.9916895756311814
test 데이터 :  0.8786493659687408

In [40]:

# 머신 생성
kn = KNeighborsClassifier()

# 머신 학습
kn.fit(X_train, y_train)

print( "학습 데이터 : ", kn.score(X_train, y_train) )

# 학습된 머신 테스트 결과
print( "test 데이터 : ", kn.score(X_test, y_test) )

# 스케일링된 데이터로 다시 테스트

학습 데이터 :  0.9158846020159889
test 데이터 :  0.8817457976997936

In [ ]:

In [ ]:

In [43]:

# corr() : 데이터 간의 상관관계를 확인
df.corr()

Out[43]:

	age	duration	campaign	pdays	previous	y
age	1.000000	-0.004648	0.004760	-0.023758	0.001288	0.025155
duration	-0.004648	1.000000	-0.084570	-0.001565	0.001203	0.394521
campaign	0.004760	-0.084570	1.000000	-0.088628	-0.032855	-0.073172
pdays	-0.023758	-0.001565	-0.088628	1.000000	0.454820	0.103621
previous	0.001288	0.001203	-0.032855	0.454820	1.000000	0.093236
y	0.025155	0.394521	-0.073172	0.103621	0.093236	1.000000

In [45]:

import seaborn as sns

# annot = True : 상관관계 숫자를 출력
sns.heatmap( df.corr(), annot=True )

Out[45]:

<Axes: >

In [55]:

# features = ['age', 'duration', 'campaign', 'pdays', 'previous']
# features = ['age', 'duration', 'campaign', 'previous']
# features = ['age', 'campaign', 'previous']
features = ['age', 'campaign', 'previous']
label = 'y'
X, y = df[features], df[label]

sc = StandardScaler()
sc.fit( X )
X_scaler = sc.transform( X )

X_train, X_test, y_train, y_test = train_test_split(X_scaler, y, test_size=0.3)

In [56]:

rfc = RandomForestClassifier()
rfc.fit(X_train, y_train);
print( "학습 데이터 : ", rfc.score(X_train, y_train) )
print( "test 데이터 : ", rfc.score(X_test, y_test) )

kn = KNeighborsClassifier()
kn.fit(X_train, y_train)
print( "학습 데이터 : ", kn.score(X_train, y_train) )
print( "test 데이터 : ", kn.score(X_test, y_test) )

학습 데이터 :  0.8956615160994723
test 데이터 :  0.8768799764081392
학습 데이터 :  0.8799886245141719
test 데이터 :  0.8695812444706577

 

 

 

 

 

하이퍼 파라미터

하이퍼파라미터¶

• 예측력을 높이기 위해 사용
• 과대/과소 적합을 방지하기 위해 사용
• 사용자가 지정하는 파라미터

하이퍼파라미터 튜닝¶

• 특정 알고리즘의 매개변수 값을 변경하면서 최적의 파라미터를 찾는 방식
• GridSearchCV클래스를 통해 하이퍼파라미터 탐색과 교차 검증을 한번에 수행

GridSearchCV¶

• 교차 검증으로 하이퍼파라미터 탐색을 수행한다
• 최상의 모델을 찾은 후 훈련 세트 전체를 사용해 최종 모델을 훈련한다
• 매개변수
  • GridSearchCV(모델, param_grid = 파라미터, cv=반복횟수, n_jobs=코어 수(-1, 모든 코어 사용))

In [2]:

# 교차 검증이란?
#  : 70 퍼센트의 학습용 데이터를 다시 쪼개서 학습하고 쪼개서 학습한 단위를
#  : 단위 학습이 끝날 때마다 테스트를 진행

K-최근접 이웃 알고리즘¶

• 주위에서 가장 가까운 다른 데이터를 보고 현재 데이터를 판단

하이퍼파라미터¶

• n_neighbors
  • 기본 가까운 5개의 데이터를 보고 자기 자신이 어디에 속하는지를 판단
  • 비교하고자 하는 데이터의 수가 적을 수록 과대 적합이 된다
• metric : 거리계산 척도
  • euclidean(녹색) : 유클리디안 거리 측정
    • 목표 지점까지 가장 짧은 거리
  • manhattan(빨간색) : 맨하튼 거리 측정 방법
    • 찾아가는 경로의 모든 길이의 합
• weights : 가중치
  • uniform : 거리에 가중치 부여하지 않음(균일한 가중치)
  • distance : 거리에 가중치 부여(가까이 있는 데이터에 가중치)

In [ ]:

In [ ]:

In [3]:

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
import pandas as pd
import warnings
warnings.filterwarnings("ignore")

In [4]:

df = pd.read_csv("../data_set/5.스케일링/titanic_cleaning.csv")
df.head()

Out[4]:

	PassengerId	Survived	Pclass	Sex	Age	SibSp	Parch	Fare
0	1	0	3	0	22.0	1	0	7.2500
1	2	1	1	1	38.0	1	0	71.2833
2	3	1	3	1	26.0	0	0	7.9250
3	4	1	1	1	35.0	1	0	53.1000
4	5	0	3	0	35.0	0	0	8.0500

In [6]:

df.columns

Out[6]:

Index(['PassengerId', 'Survived', 'Pclass', 'Sex', 'Age', 'SibSp', 'Parch',
       'Fare'],
      dtype='object')

In [19]:

features = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare']
label = "Survived"
X, y = df[features], df[label]

In [20]:

minMaxScaler = MinMaxScaler()
minMaxScaler.fit(X)
X_scaler = minMaxScaler.transform(X)

In [21]:

# 학습용 80%, 테스트용 20%
X_train_minMax, X_test_minMax, y_train, y_test = train_test_split(X_scaler, y, test_size=0.2)

In [22]:

# 알고리즘 생성
knn = KNeighborsClassifier()

knn.fit(X_train_minMax, y_train)

print("train ", knn.score(X_train_minMax, y_train))
print("test ", knn.score(X_test_minMax, y_test))

train  0.8721910112359551
test  0.8212290502793296

In [25]:

k_param = range(1, 11)
train_list = []
test_list = []
for k in k_param:
    knn = KNeighborsClassifier( n_neighbors=k )
    knn.fit(X_train_minMax, y_train)
    # print("k : ", k, "train : ", knn.score(X_train_minMax, y_train), knn.score(X_test_minMax, y_test))
    train_list.append(knn.score(X_train_minMax, y_train))
    test_list.append(knn.score(X_test_minMax, y_test))

dic = {
    "k" : k_param,
    "train 정확도" : train_list,
    "test 정확도" : test_list
}

score_df = pd.DataFrame(dic)
score_df

Out[25]:

	k	train 정확도	test 정확도
0	1	0.985955	0.754190
1	2	0.896067	0.793296
2	3	0.887640	0.810056
3	4	0.863764	0.826816
4	5	0.872191	0.821229
5	6	0.855337	0.826816
6	7	0.851124	0.804469
7	8	0.838483	0.821229
8	9	0.839888	0.787709
9	10	0.841292	0.787709

In [29]:

import matplotlib.pyplot as plt
import seaborn as sns

plt.rc("font", family = "Malgun Gothic")

fig, ax = plt.subplots( figsize = (5,5) )

sns.lineplot( x="k", y="train 정확도", data=score_df )
sns.lineplot( x="k", y="test 정확도", data=score_df )

Out[29]:

<Axes: xlabel='k', ylabel='train 정확도'>

In [32]:

from sklearn.model_selection import GridSearchCV

# params = {
#     "n_neighbors" : k_param
# }

params = {
    "n_neighbors" : range(1, 11),
    "metric" : ["manhattan", "euclidean"],
    "weights" : ["uniform", "distance"]
}

knn = KNeighborsClassifier()

grid_cv = GridSearchCV(knn, param_grid=params, cv=5, n_jobs=-1)
grid_cv.fit( X_train_minMax, y_train )
print("최적의 하이퍼 파라미터 : ", grid_cv.best_params_ )

print( grid_cv.score( X_train_minMax, y_train ) )
print( grid_cv.score( X_test_minMax, y_test ) )

최적의 하이퍼 파라미터 :  {'metric': 'manhattan', 'n_neighbors': 4, 'weights': 'uniform'}
0.8665730337078652
0.8379888268156425

In [33]:

knn = KNeighborsClassifier(n_neighbors=3, metric="manhattan", weights="uniform")
knn.fit( X_train_minMax, y_train )

print( knn.score( X_train_minMax, y_train ) )
print( knn.score( X_test_minMax, y_test ) )

0.8834269662921348
0.8268156424581006

In [ ]:

In [ ]:

랜덤 포레스트 하이퍼 파라미터¶

• n_estimators
  • 트리의 개수. default=10
  • 트리의 개수가 많이면 성능은 좋아지지만, 시간이 오래 걸릴수 있다.
• max_depth
  • 트리의 최대 깊이. default = None
  • 완벽하게 파라미터값이 결정될 때 까지 분할 또는 min_samples_split보자 작아질 때까지 분할
  • 깊이가 깊어지면 과대적합될 수 있으므로 적절히 제어 필요
• min_samples_leaf
  • 맆노드(자식노드가 없는 노드)가 되기 위해 최소한의 샘플 데이터 수
  • min_samples_split과 함께 과대적합 제어용도
  • 불균형 데이터가 있는 경우 작게 설정하는게 좋다

In [34]:

from sklearn.ensemble import RandomForestClassifier

df = pd.read_csv("../data_set/5.스케일링/titanic_cleaning.csv")
df.head()

Out[34]:

	PassengerId	Survived	Pclass	Sex	Age	SibSp	Parch	Fare
0	1	0	3	0	22.0	1	0	7.2500
1	2	1	1	1	38.0	1	0	71.2833
2	3	1	3	1	26.0	0	0	7.9250
3	4	1	1	1	35.0	1	0	53.1000
4	5	0	3	0	35.0	0	0	8.0500

In [35]:

df.columns

Out[35]:

Index(['PassengerId', 'Survived', 'Pclass', 'Sex', 'Age', 'SibSp', 'Parch',
       'Fare'],
      dtype='object')

In [36]:

f = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare']
label = "Survived"
X, y = df[f], df[label]

In [37]:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
rfc = RandomForestClassifier()
rfc.fit(X_train, y_train)
print("train : ", rfc.score(X_train, y_train))
print("test : ", rfc.score(X_test, y_test))

train :  0.9873595505617978
test :  0.8324022346368715

In [43]:

rfc = RandomForestClassifier(n_estimators=10, max_depth=10000, min_samples_leaf=10)
rfc.fit(X_train, y_train)
print("train : ", rfc.score(X_train, y_train))
print("test : ", rfc.score(X_test, y_test))

train :  0.8581460674157303
test :  0.8212290502793296

In [45]:

params = {
    "n_estimators" : range(10, 101, 10),
    "max_depth" : range(4, 11, 2),
    "min_samples_leaf" : range(5, 21, 5)
}
rfc = RandomForestClassifier()

grid_cv = GridSearchCV( rfc, param_grid=params, cv=3, n_jobs=-1 )
grid_cv.fit( X_train, y_train )
print("최적의 하이퍼파라미터 : ", grid_cv.best_params_)
print("train : ", grid_cv.score(X_train, y_train))
print("test : ", grid_cv.score(X_test, y_test))

최적의 하이퍼파라미터 :  {'max_depth': 8, 'min_samples_leaf': 5, 'n_estimators': 50}
train :  0.8764044943820225
test :  0.8156424581005587

In [46]:

grid_cv.predict( X_train )

Out[46]:

array([1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1,
       0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1,
       0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0,
       0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0,
       1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1,
       0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0,
       0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
       0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0,
       0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
       0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
       0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1,
       0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
       0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1,
       0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
       1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1,
       0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0,
       1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0,
       0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0,
       0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1,
       0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1,
       0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0,
       0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
       1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0,
       0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1,
       1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0,
       1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0,
       1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0,
       1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1,
       1, 0, 0, 0, 1, 0, 0, 1], dtype=int64)

In [ ]:

In [ ]:

하이퍼파라미터¶

• n_estimators
  • 학습기의 수 설정.
  • 많으면 예측률은 올라가나 시간이 오래걸릴 수 있음.
• learning_rate
  • GBM이 학습을 진행할 때마다 적용하는 학습률로서 순차적으로 오류 값을 보정해가는 데 적용하는 수 이다
  • 0~1 사이의 값으로 지정한다. default=0.1
  • 너무 작은 값이면 업데이트를 너무 많이 하게 되어 꼼꼼하지만 시간이 오래 걸린다
  • 너무 큰 값이면 최소 오류 값을 찾지 못할 수 있지만 빠르다
• subsample
  • 학습기가 학습에 사용하는 데이터 샘플의 비율(0~1). default=1.
  • 0.5일경우 50%학습데이터를 사용한다는 것이다
  • 과대적합을 줄이려면 작은 값을 적용해야 한다.

In [47]:

from sklearn.ensemble import GradientBoostingClassifier
gb = GradientBoostingClassifier()
gb.fit(X_train, y_train)
print("train : ", gb.score(X_train, y_train))
print("test : ", gb.score(X_test, y_test))

train :  0.9044943820224719
test :  0.8212290502793296

In [54]:

gb = GradientBoostingClassifier( learning_rate=0.1, n_estimators=100, subsample=0.9 )
gb.fit(X_train, y_train)
print("train : ", gb.score(X_train, y_train))
print("test : ", gb.score(X_test, y_test))

train :  0.9058988764044944
test :  0.8324022346368715

In [59]:

import numpy as np

params = {
    "learning_rate" :[0.1, 0.3, 0.5, 0.7, 0.9],
    "n_estimators" : [100, 200, 300, 400, 500],
    "subsample" : np.arange(0.1, 1, 0.2)
}

gb = GradientBoostingClassifier()

grid_cv = GridSearchCV( gb, param_grid=params, cv=3, n_jobs=-1 )
grid_cv.fit(X_train, y_train)
print("파라미터 : ", grid_cv.best_params_)
print("train : ", grid_cv.score(X_train, y_train))
print("test : ", grid_cv.score(X_test, y_test))

파라미터 :  {'learning_rate': 0.1, 'n_estimators': 100, 'subsample': 0.5000000000000001}
train :  0.898876404494382
test :  0.8491620111731844

 

 

728x90