딥러닝 텐서플로우에서 학습시 epoch 와 batch_size 에 대한 설명, dummy variable trap, 분류의 문제 모델링 하는 방법, 실무 예시

금융상품 갱신 여부 예측하는 ANN¶

Churn_Modelling.csv 파일을 보면, 고객 정보와 해당 고객이 금융상품을 갱신했는지 안했는지의 여부에 대한 데이터가 있다.

이 데이터를 가지고 갱신여부를 예측하는 딥러닝을 구성하시오.

In [ ]:

Neural Networks and Deep Learning¶

In [ ]:

In [1]:

# Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
%matplotlib inline

In [3]:

# Churn_Modelling.csv 파일을 읽어올것이다.
# 구글 드라이브를 연동해서 읽어온다.

In [4]:

from google.colab import drive
drive.mount('/content/drive')

Mounted at /content/drive

In [ ]:

# 파이썬에서 디렉토리 경로 이동하는 방법

In [7]:

import os

In [8]:

os.chdir('/content/drive/MyDrive/Colab Notebooks/ml_plus/data')

In [9]:

df = pd.read_csv('Churn_Modelling.csv')

In [10]:

df

Out[10]:

	RowNumber	CustomerId	Surname	CreditScore	Geography	Gender	Age	Tenure	Balance	NumOfProducts	HasCrCard	IsActiveMember	EstimatedSalary	Exited
0	1	15634602	Hargrave	619	France	Female	42	2	0.00	1	1	1	101348.88	1
1	2	15647311	Hill	608	Spain	Female	41	1	83807.86	1	0	1	112542.58	0
2	3	15619304	Onio	502	France	Female	42	8	159660.80	3	1	0	113931.57	1
3	4	15701354	Boni	699	France	Female	39	1	0.00	2	0	0	93826.63	0
4	5	15737888	Mitchell	850	Spain	Female	43	2	125510.82	1	1	1	79084.10	0
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
9995	9996	15606229	Obijiaku	771	France	Male	39	5	0.00	2	1	0	96270.64	0
9996	9997	15569892	Johnstone	516	France	Male	35	10	57369.61	1	1	1	101699.77	0
9997	9998	15584532	Liu	709	France	Female	36	7	0.00	1	0	1	42085.58	1
9998	9999	15682355	Sabbatini	772	Germany	Male	42	3	75075.31	2	1	0	92888.52	1
9999	10000	15628319	Walker	792	France	Female	28	4	130142.79	1	1	0	38190.78	0

10000 rows × 14 columns

In [ ]:

# nan 있는지 확인

In [11]:

df.isna().sum()

Out[11]:

RowNumber          0
CustomerId         0
Surname            0
CreditScore        0
Geography          0
Gender             0
Age                0
Tenure             0
Balance            0
NumOfProducts      0
HasCrCard          0
IsActiveMember     0
EstimatedSalary    0
Exited             0
dtype: int64

In [ ]:

# X, y 로 분리

In [12]:

y = df['Exited']

In [13]:

df.head(2)

Out[13]:

	RowNumber	CustomerId	Surname	CreditScore	Geography	Gender	Age	Tenure	Balance	NumOfProducts	HasCrCard	IsActiveMember	EstimatedSalary	Exited
0	1	15634602	Hargrave	619	France	Female	42	2	0.00	1	1	1	101348.88	1
1	2	15647311	Hill	608	Spain	Female	41	1	83807.86	1	0	1	112542.58	0

In [14]:

X = df.loc[ : , 'CreditScore': 'EstimatedSalary' ]

In [15]:

X

Out[15]:

	CreditScore	Geography	Gender	Age	Tenure	Balance	NumOfProducts	HasCrCard	IsActiveMember	EstimatedSalary
0	619	France	Female	42	2	0.00	1	1	1	101348.88
1	608	Spain	Female	41	1	83807.86	1	0	1	112542.58
2	502	France	Female	42	8	159660.80	3	1	0	113931.57
3	699	France	Female	39	1	0.00	2	0	0	93826.63
4	850	Spain	Female	43	2	125510.82	1	1	1	79084.10
...	...	...	...	...	...	...	...	...	...	...
9995	771	France	Male	39	5	0.00	2	1	0	96270.64
9996	516	France	Male	35	10	57369.61	1	1	1	101699.77
9997	709	France	Female	36	7	0.00	1	0	1	42085.58
9998	772	Germany	Male	42	3	75075.31	2	1	0	92888.52
9999	792	France	Female	28	4	130142.79	1	1	0	38190.78

10000 rows × 10 columns

In [16]:

y

Out[16]:

0       1
1       0
2       1
3       0
4       0
       ..
9995    0
9996    0
9997    1
9998    1
9999    0
Name: Exited, Length: 10000, dtype: int64

In [ ]:

# 문자열 데이터는 숫자로 바꿔줘야 한다.

In [21]:

df['Geography'].nunique()

Out[21]:

3

In [22]:

df['Gender'].nunique()

Out[22]:

2

In [20]:

from sklearn.preprocessing import OneHotEncoder, LabelEncoder

In [23]:

from sklearn.compose import ColumnTransformer

In [25]:

label_encoder = LabelEncoder()

In [27]:

X['Gender'] = label_encoder.fit_transform(X['Gender'])

In [28]:

ct = ColumnTransformer( [ ('encoder', OneHotEncoder(), [1] ) ], 
                       remainder='passthrough')

In [29]:

X = ct.fit_transform(X.values)

In [30]:

X

Out[30]:

array([[1.0, 0.0, 0.0, ..., 1, 1, 101348.88],
       [0.0, 0.0, 1.0, ..., 0, 1, 112542.58],
       [1.0, 0.0, 0.0, ..., 1, 0, 113931.57],
       ...,
       [1.0, 0.0, 0.0, ..., 0, 1, 42085.58],
       [0.0, 1.0, 0.0, ..., 1, 0, 92888.52],
       [1.0, 0.0, 0.0, ..., 1, 0, 38190.78]], dtype=object)

In [ ]:

# dummy variable trap
#
# France, Germerny, Spain 3개 컬럼으로 만들었는데,
# 실제로는 원핫 인코딩을 수행한 후에, 맨 왼쪽 컬럼은 삭제해도 
# 0 과 1로 데이터를 전부 나타낼 수 있다.

# 즉, France 컬럼을 삭제해도

#  Germerny , Spain 
#     0         0        => 프랑스 
#     1         0        => 독일
#     0         1        => 스페인

# 이렇게 맨 왼쪽 france 컬럼을 삭제해도, 3개의 데이터를 모두 나타낼수있다.[속도를위해서]

In [31]:

# 삭제하는 두가지방법 넘파이로 하거나, 판다스로 하거나  
X_df = pd.DataFrame(X)

In [32]:

X_df.drop(0, axis = 1, inplace=True)

In [33]:

X_df

Out[33]:

	1	2	3	4	5	6	7	8	9	10	11
0	0.0	0.0	619	0	42	2	0.0	1	1	1	101348.88
1	0.0	1.0	608	0	41	1	83807.86	1	0	1	112542.58
2	0.0	0.0	502	0	42	8	159660.8	3	1	0	113931.57
3	0.0	0.0	699	0	39	1	0.0	2	0	0	93826.63
4	0.0	1.0	850	0	43	2	125510.82	1	1	1	79084.1
...	...	...	...	...	...	...	...	...	...	...	...
9995	0.0	0.0	771	1	39	5	0.0	2	1	0	96270.64
9996	0.0	0.0	516	1	35	10	57369.61	1	1	1	101699.77
9997	0.0	0.0	709	0	36	7	0.0	1	0	1	42085.58
9998	1.0	0.0	772	1	42	3	75075.31	2	1	0	92888.52
9999	0.0	0.0	792	0	28	4	130142.79	1	1	0	38190.78

10000 rows × 11 columns

In [34]:

X = X_df.values

In [35]:

X

Out[35]:

array([[0.0, 0.0, 619, ..., 1, 1, 101348.88],
       [0.0, 1.0, 608, ..., 0, 1, 112542.58],
       [0.0, 0.0, 502, ..., 1, 0, 113931.57],
       ...,
       [0.0, 0.0, 709, ..., 0, 1, 42085.58],
       [1.0, 0.0, 772, ..., 1, 0, 92888.52],
       [0.0, 0.0, 792, ..., 1, 0, 38190.78]], dtype=object)

In [ ]:

X[ : , 1 : ]  # 넘파이

In [ ]:

# 피처스케일링한다.

In [ ]:

##### 딥러닝은 무.조.건 피처스케일링 해야 한다 ######  (0과 1사이로 만들기)

In [36]:

from sklearn.preprocessing import MinMaxScaler

In [37]:

X

Out[37]:

array([[0.0, 0.0, 619, ..., 1, 1, 101348.88],
       [0.0, 1.0, 608, ..., 0, 1, 112542.58],
       [0.0, 0.0, 502, ..., 1, 0, 113931.57],
       ...,
       [0.0, 0.0, 709, ..., 0, 1, 42085.58],
       [1.0, 0.0, 772, ..., 1, 0, 92888.52],
       [0.0, 0.0, 792, ..., 1, 0, 38190.78]], dtype=object)

In [38]:

y

Out[38]:

0       1
1       0
2       1
3       0
4       0
       ..
9995    0
9996    0
9997    1
9998    1
9999    0
Name: Exited, Length: 10000, dtype: int64

In [39]:

scaler_X = MinMaxScaler()

In [40]:

X = scaler_X.fit_transform(X)

In [42]:

# 학습용과 테스트용으로 데이터를 나눈다. (검증을 위해서)

In [43]:

from sklearn.model_selection import train_test_split

In [44]:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

In [45]:

X_train.shape

Out[45]:

(8000, 11)

In [46]:

X_test.shape

Out[46]:

(2000, 11)

In [47]:

y_train.shape

Out[47]:

(8000,)

In [48]:

y_test.shape  # 테스트 사이즈로 나눈값이 8대2로 정상적으로 들어있음을 확인할수있다. 

Out[48]:

(2000,)

In [50]:

#  첫번째 사람을 가져와바라. (df.loc 와 유사하다.)
X_train[ 0, : ]

Out[50]:

array([0.        , 1.        , 0.634     , 0.        , 0.21621622,
       0.5       , 0.        , 0.33333333, 1.        , 0.        ,
       0.81917353])

In [53]:

y_train

Out[53]:

7389    0
9275    0
2995    0
5316    0
356     0
       ..
9225    0
4859    0
3264    0
9845    0
2732    1
Name: Exited, Length: 8000, dtype: int64

In [51]:

y_train.values[0]   # 판다스 시리즈기 때문에, values로 넘파이로 만들어서 확인했다.

Out[51]:

0

In [52]:

# Part 2 - Now let's make the ANN!
# 텐서는 구글, 파이토치는 페이스북꺼
import tensorflow as tf
from tensorflow import keras
from keras.models import Sequential
from keras.layers import Dense

In [ ]:

# 레이어는 구조로 되어있다
# 구조를 먼저 갖춰야한다. == 틀을만든다.

In [64]:

model = Sequential()

In [65]:

# 히든레이어 먼저 만든다.  레이어 == Dense(), 노드6 == 뉴런6 == units= 6 , activation == 예측,학습에 사용할 함수 (일괄셋팅해야함==통일해야함)
# 시그모어 탄젠트는 히든에서 사용하지 않는다. 로컬미니마에서 멈추는 문제때문에
# 인풋이 몇개인지 알려줘야한다 == input_shape , X의 열이 11개이다. 튜플로쓴다.(shape는 튜플이니까)
# 선을 만드는 작업을 한것이다 (가중치 , w, param)
model.add( Dense(units = 6, activation = 'relu', input_shape = (11,) ))

In [66]:

# 두번째 히든레이어를 만든다 tf.nn.relu == activation = 'relu' 와 같다 편리성을 위한것.
model.add( Dense(units = 8, activation = tf.nn.relu) )

In [67]:

# 아웃풋 레이어 설정
# 결과값이 2개로 분류되어있는 문제에 최종 레이어는 시그모이드를 사용한다.
model.add( Dense(units = 1, activation = 'sigmoid') )

In [68]:

model.summary() # 요약해봐라
# 첫번째 레이어 dense (Dense)               (None, 6)                 72     ( 인풋레이어와 연결된 선의 총 갯수 12*6 = 72 (11 *6 이아닌 이유는 상수항이 추가되기 때문.))  
# 두번째 레이어 dense_1 (Dense)             (None, 8)                 56     ( 여기도 상수항이 생긴다. 7*8=56)
# 세번째 레이어 dense_2 (Dense)             (None, 1)                 9      

Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense_3 (Dense)             (None, 6)                 72        
                                                                 
 dense_4 (Dense)             (None, 8)                 56        
                                                                 
 dense_5 (Dense)             (None, 1)                 9         
                                                                 
=================================================================
Total params: 137
Trainable params: 137
Non-trainable params: 0
_________________________________________________________________

In [ ]:

# 모델링이 끝나면, 컴파일(Compile)을 해야한다.
# 컴파일이란, 옵티마이저(optimizer)와 로스펑션(loss function 오차함수, 손실함수), 검증방법을 셋팅

In [69]:

# optimizer == 오차를 찾는과정 알고리즘 설정
# 2개로 분류하는 문제의 loss 는 'binary_crossentropy' 을 설정한다. (외우자)
# metrics == [여러개가능]로 검증, accuracy == 정확도
model.compile(optimizer = 'adam', loss = 'binary_crossentropy' , metrics= [ 'accuracy'])

In [ ]:

# 컴파일이 끝나면, 학습을 한다.

In [ ]:

###### 주.의.점 : 학습 코드를 실행한후에, 다시 학습하고 싶을때는, 모델링 부분부터 다시 실행해야 합니다. 

In [62]:

X_train.shape

Out[62]:

(8000, 11)

In [61]:

model.fit(X_train, y_train)   #  1s 2ms/step 1개당 2ms 초가 걸렸다. loss: 0.5142 오차 == binary_crossentropy, accuracy: 0.7886 == 메트릭스에 쓴것이 나온것 == 79%

250/250 [==============================] - 1s 2ms/step - loss: 0.5142 - accuracy: 0.7886

Out[61]:

<keras.callbacks.History at 0x7fba82dbb730>

In [63]:

8000/250 # 한번에 32개를 250번에걸쳐 학습 == batch가 32개 

Out[63]:

32.0

In [70]:

# 업그레이드 학습
# 처음부터 다시학습. 10개의 행을 하나에 노드에 가져오고 20번 반복학습시키겠다는 의미.
model.fit(X_train, y_train, batch_size = 10, epochs= 20 ) 

Epoch 1/20
800/800 [==============================] - 3s 3ms/step - loss: 0.5116 - accuracy: 0.7950
Epoch 2/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4750 - accuracy: 0.7960
Epoch 3/20
800/800 [==============================] - 2s 2ms/step - loss: 0.4653 - accuracy: 0.7960
Epoch 4/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4574 - accuracy: 0.7960
Epoch 5/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4480 - accuracy: 0.8041
Epoch 6/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4366 - accuracy: 0.8117
Epoch 7/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4280 - accuracy: 0.8201
Epoch 8/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4228 - accuracy: 0.8245
Epoch 9/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4197 - accuracy: 0.8259
Epoch 10/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4172 - accuracy: 0.8291
Epoch 11/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4166 - accuracy: 0.8259
Epoch 12/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4149 - accuracy: 0.8284
Epoch 13/20
800/800 [==============================] - 2s 3ms/step - loss: 0.4130 - accuracy: 0.8313
Epoch 14/20
800/800 [==============================] - 2s 2ms/step - loss: 0.4128 - accuracy: 0.8299
Epoch 15/20
800/800 [==============================] - 2s 2ms/step - loss: 0.4121 - accuracy: 0.8295
Epoch 16/20
800/800 [==============================] - 2s 2ms/step - loss: 0.4106 - accuracy: 0.8304
Epoch 17/20
800/800 [==============================] - 2s 2ms/step - loss: 0.4116 - accuracy: 0.8301
Epoch 18/20
800/800 [==============================] - 2s 2ms/step - loss: 0.4108 - accuracy: 0.8300
Epoch 19/20
800/800 [==============================] - 2s 3ms/step - loss: 0.4094 - accuracy: 0.8320
Epoch 20/20
800/800 [==============================] - 1s 2ms/step - loss: 0.4091 - accuracy: 0.8307

Out[70]:

<keras.callbacks.History at 0x7fba7e7f7490>

In [ ]:

# 학습이 끝나면, 평가를 한다.

In [71]:

model.evaluate(X_test, y_test)

63/63 [==============================] - 0s 2ms/step - loss: 0.4057 - accuracy: 0.8380

Out[71]:

[0.40567252039909363, 0.8379999995231628]

In [ ]:

# 컨퓨전 매트릭스를 확인하여, 어떤 문제를 잘 맞추고 못맞추는지 확인

In [72]:

from sklearn.metrics import confusion_matrix, accuracy_score

In [74]:

y_pred = model.predict(X_test)

63/63 [==============================] - 0s 1ms/step

In [75]:

# 예측값과 테스트값을 비교하는데,
# 시그모이드로해서 0과1사이로 나왔다.
# 그렇기때문에 0.5 < 1 로 아니면 0으로 만든다.
y_pred 

Out[75]:

array([[0.24005297],
       [0.30040523],
       [0.2359911 ],
       ...,
       [0.177605  ],
       [0.14759308],
       [0.11133963]], dtype=float32)

In [76]:

y_test 

Out[76]:

9394    0
898     1
2398    0
5906    0
2343    0
       ..
1037    0
2899    0
9549    0
2740    0
6690    0
Name: Exited, Length: 2000, dtype: int64

In [80]:

y_pred = (y_pred > 0.5).astype(int) # True False로 나오지기때문에 , 넘파이 함수인 astype으로 변경

In [148]:

cm = confusion_matrix(y_test, y_pred) # 최종예측

In [150]:

cm

Out[150]:

array([[1547,   48],
       [ 276,  129]])

In [149]:

(1547+129) / cm.sum() # 맞춘거(1547+129)개 틀린거 48개, 276개 

# 이렇게하는거나 밑에거로 하는거나 결과값은 같다.

Out[149]:

0.838

In [83]:

accuracy_score(y_test, y_pred) 

Out[83]:

0.838

In [ ]:

# 사용자가 설정해야될것, 히든레이어, 배치사이즈, 에포크 == 하이퍼파라미터 == 사람이결정해야될 수치 
# (정답이 없으므로 실험을 해야한다.)
# 파라미터 == 선의숫자, w

In [ ]:

다음 신규 데이터를 통해 분류해 보자¶

• Geography: France
• Credit Score: 600
• Gender: Male
• Age: 40
• Tenure: 3
• Balance: 60000
• Number of Products: 2
• Has Credit Card: Yes
• Is Active Member: Yes
• Estimated Salary: 50000

In [99]:

# 이런형태와 같게 만들어줘야한다. (1행)
X_train[0,:]

Out[99]:

array([0.        , 1.        , 0.634     , 0.        , 0.21621622,
       0.5       , 0.        , 0.33333333, 1.        , 0.        ,
       0.81917353])

In [101]:

model.layers[0] # 레이어의 리스트인데 0번째 레이어를 가져와보자.

Out[101]:

<keras.layers.core.dense.Dense at 0x7fba811da910>

In [103]:

model.layers[0].weights  # 학습한 결과의 선에있는 숫자를 확인

Out[103]:

[<tf.Variable 'dense_3/kernel:0' shape=(11, 6) dtype=float32, numpy=
 array([[-0.5619218 , -0.30537778,  0.127162  ,  0.05105464,  0.510115  ,
          0.10068943],
        [-0.46249005, -0.26511666, -0.4411415 ,  0.15406252,  0.35294303,
          0.2779059 ],
        [ 0.4446758 , -0.50742596, -0.10636649,  0.14193307,  0.29976186,
          0.33581913],
        [ 0.23433976, -0.52330774, -0.33920982,  0.14784725, -0.21266907,
         -0.12802877],
        [-0.6397812 , -0.57191765, -0.87790513, -2.01802   ,  0.7279507 ,
         -0.77708197],
        [ 0.24350047,  0.16897699, -0.15312533,  0.10083929,  0.15491815,
          0.15257308],
        [-0.36781976, -0.49725294,  0.4712732 , -0.09534372,  0.5201495 ,
          0.48889315],
        [ 0.21710207, -0.16822176, -0.03382034,  0.1281617 ,  0.17358644,
          0.32902253],
        [-0.02378772,  0.22061142,  0.15340945,  0.07237855,  0.17580971,
          0.00598443],
        [ 0.60578394, -0.30613202, -0.37804127, -0.21168992, -0.6386848 ,
          0.6392392 ],
        [-0.39497963, -0.13203742,  0.17515592,  0.15897782,  0.09825026,
         -0.1483091 ]], dtype=float32)>,
 <tf.Variable 'dense_3/bias:0' shape=(6,) dtype=float32, numpy=
 array([ 0.3636443 , -0.06558595,  0.2679751 ,  0.6206699 , -0.18987603,
         0.26178893], dtype=float32)>]

In [104]:

model.layers[1].weights

Out[104]:

[<tf.Variable 'dense_4/kernel:0' shape=(6, 8) dtype=float32, numpy=
 array([[-0.47932643,  0.5675276 , -0.49622226,  0.6041433 ,  0.56867427,
         -0.05892293,  0.37422118, -0.0523892 ],
        [ 0.25005615, -0.3136205 , -0.05903131, -0.462368  ,  0.3946033 ,
         -0.08723802, -0.3129512 , -0.441948  ],
        [-0.07612425,  0.18642052, -0.5593573 , -0.42842287, -0.72467786,
          0.5274387 ,  0.31228012, -0.46014208],
        [-0.60211694,  0.5190461 , -0.5013196 ,  1.0520077 , -0.79789   ,
          0.50602823,  0.97789556, -0.37298793],
        [-0.32876873, -0.35014617, -0.3043916 , -0.04368088,  0.6717737 ,
         -0.3944252 , -0.01016968,  0.7095939 ],
        [-0.56390905, -0.12931302, -0.46742567,  0.53602904, -0.3090403 ,
          0.49801648, -0.38584325, -1.1228883 ]], dtype=float32)>,
 <tf.Variable 'dense_4/bias:0' shape=(8,) dtype=float32, numpy=
 array([ 0.        ,  0.2383901 ,  0.        , -0.03822036,  0.08421005,
         0.20013738,  0.12192951,  0.26127154], dtype=float32)>]

In [106]:

model.layers[0].get_weights() # 위의것과 같은기능

Out[106]:

[array([[-0.5619218 , -0.30537778,  0.127162  ,  0.05105464,  0.510115  ,
          0.10068943],
        [-0.46249005, -0.26511666, -0.4411415 ,  0.15406252,  0.35294303,
          0.2779059 ],
        [ 0.4446758 , -0.50742596, -0.10636649,  0.14193307,  0.29976186,
          0.33581913],
        [ 0.23433976, -0.52330774, -0.33920982,  0.14784725, -0.21266907,
         -0.12802877],
        [-0.6397812 , -0.57191765, -0.87790513, -2.01802   ,  0.7279507 ,
         -0.77708197],
        [ 0.24350047,  0.16897699, -0.15312533,  0.10083929,  0.15491815,
          0.15257308],
        [-0.36781976, -0.49725294,  0.4712732 , -0.09534372,  0.5201495 ,
          0.48889315],
        [ 0.21710207, -0.16822176, -0.03382034,  0.1281617 ,  0.17358644,
          0.32902253],
        [-0.02378772,  0.22061142,  0.15340945,  0.07237855,  0.17580971,
          0.00598443],
        [ 0.60578394, -0.30613202, -0.37804127, -0.21168992, -0.6386848 ,
          0.6392392 ],
        [-0.39497963, -0.13203742,  0.17515592,  0.15897782,  0.09825026,
         -0.1483091 ]], dtype=float32),
 array([ 0.3636443 , -0.06558595,  0.2679751 ,  0.6206699 , -0.18987603,
         0.26178893], dtype=float32)]

In [107]:

# 신규데이터를 받았을때 진행을 시물레이션
df.head(2)

Out[107]:

	RowNumber	CustomerId	Surname	CreditScore	Geography	Gender	Age	Tenure	Balance	NumOfProducts	HasCrCard	IsActiveMember	EstimatedSalary	Exited
0	1	15634602	Hargrave	619	France	Female	42	2	0.00	1	1	1	101348.88	1
1	2	15647311	Hill	608	Spain	Female	41	1	83807.86	1	0	1	112542.58	0

In [120]:

new_data2 = np.array( [ 600, 'France', 'Male', 40, 3 , 60000, 2 , 1 , 1,50000]) 

In [124]:

new_data2

Out[124]:

array(['600', 'France', 'Male', '40', '3', '60000', '2', '1', '1',
       '50000'], dtype='<U21')

In [125]:

new_data2.shape

Out[125]:

(10,)

In [123]:

X_test.shape

Out[123]:

(2000, 11)

In [133]:

new_data2 = new_data2.reshape(1, 10) # 1행 10열로 변경

In [134]:

new_data2

Out[134]:

array([['600', 'France', 'Male', '40', '3', '60000', '2', '1', '1',
        '50000']], dtype='<U21')

In [135]:

# 레이블인코딩
# 인코더나 피처스케일러는 벡터 (1차원) 은 들어갈수가 없고 2차원이들어가야한다.
new_data2[ :,2 ] = label_encoder.transform(new_data2[ :,2 ]) # 위와는 다르게 슬라이싱으로 컬럼을 지정했다.

In [136]:

new_data2 # 레이블 변환확인

Out[136]:

array([['600', 'France', '1', '40', '3', '60000', '2', '1', '1', '50000']],
      dtype='<U21')

In [137]:

# 원핫인코딩
new_data2 = ct.transform(new_data2)

In [138]:

new_data2 # 원핫변환 확인

Out[138]:

array([['1.0', '0.0', '0.0', '600', '1', '40', '3', '60000', '2', '1',
        '1', '50000']], dtype='<U32')

In [139]:

# 맨왼쪽 칼럼 드랍 == 더미 밸류어블 트랩 == 없어도 의미를 파악할수 있는 컬럼
new_data2 = new_data2[:, 1: ]

In [140]:

new_data2

Out[140]:

array([['0.0', '0.0', '600', '1', '40', '3', '60000', '2', '1', '1',
        '50000']], dtype='<U32')

In [ ]:

# 피처스케일링

In [141]:

new_data2 = scaler_X.transform(new_data2)

In [142]:

new_data2 # 스케일링 잘됬나 확인

Out[142]:

array([[0.        , 0.        , 0.5       , 1.        , 0.2972973 ,
        0.3       , 0.23914092, 0.33333333, 1.        , 1.        ,
        0.24996597]])

In [143]:

new_data2.shape # 마지막으로 점검

Out[143]:

(1, 11)

In [ ]:

# 위에선 분리를 진행했지만 여기선 필요한 컬럼만 있으므로 분리할필요가없어,
# 예측을 바로 진행한다.

In [144]:

y_pred2 = model.predict(new_data2)

1/1 [==============================] - 0s 20ms/step

In [145]:

y_pred2 # 비교할수가 없는 숫자가 나오게 되므로(시그모이드를 썻기때문) 아래를 진행.

Out[145]:

array([[0.11513481]], dtype=float32)

In [146]:

y_pred2 = (y_pred2 > 0.5).astype(int) # True False로 나온것을 astype(int)로변환

In [147]:

y_pred2 # 예측결과 1과 0 중에 0이 나왔다. 정확도는 위에서 보았던 80프로 

Out[147]:

array([[0]])

In [ ]:

In [ ]:

# 정확도가 만족스럽다면 완성이라고 볼수있다.
# 서비스 개발자에게 줘야 할것은 무엇인가?

# 학습된 레이블,원핫 인코더, 스케일러, 인공지능 
# label_encoder,ct, scaler_X, model을 주면 된다. 
# .transform(), .transform(), .transform(), .predict()는 모델에 포함되있는 함수이므로

# 여기까지 알게된다면 배포까지 되는것이다.
# 신규데이터는 서버에서 받는다.

# 줄때는 반드시 pkl(피클)로 만들어서 준다. 포괄적으로 본다면 (파일이라는 의미) 
## 텐서플로는 피클로 안되기 때문.(h5로 함.)

In [ ]:

In [ ]:

용어 정리¶

epoch

• 한 번의 epoch는 신경망에서 전체 데이터 셋에 대해 forward pass/backward pass 과정을 거친 것을 말함. 즉, 전체 데이터 셋에 대해 한 번 학습을 완료한 상태

batch_size

메모리의 한계와 속도 저하 때문에 대부분의 경우에는 한 번의 epoch에서 모든 데이터를 한꺼번에 집어넣을 수는 없습니다. 그래서 데이터를 나누어서 주게 되는데 이때 몇 번 나누어서 주는가를 iteration, 각 iteration마다 주는 데이터 사이즈를 batch size라고 합니다.

출처: https://www.slideshare.net/w0ong/ss-82372826

In [ ]:

In [ ]:

GridSearch 를 이용한, 최적의 하이퍼 파라미터 찾기¶

In [ ]:

# Tuning the ANN
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers import Dense

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]: