Python 딥 러닝-구현
이 딥 러닝 구현에서 우리의 목표는 고객이이 은행 서비스를 떠날 가능성이있는 특정 은행의 고객 이탈 또는 이탈 데이터를 예측하는 것입니다. 사용 된 데이터 세트는 비교적 작고 14 개의 열이있는 10000 개의 행을 포함합니다. 우리는 Anaconda 배포판과 Theano, TensorFlow 및 Keras와 같은 프레임 워크를 사용하고 있습니다. Keras는 백엔드로 작동하는 Tensorflow 및 Theano를 기반으로 구축되었습니다.
# Artificial Neural Network
# Installing Theano
pip install --upgrade theano
# Installing Tensorflow
pip install –upgrade tensorflow
# Installing Keras
pip install --upgrade keras
1 단계 : 데이터 전처리
In[]:
# Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Importing the database
dataset = pd.read_csv('Churn_Modelling.csv')
2 단계
데이터 집합의 특성과 "종료 됨"이라는 레이블이 붙은 14 열인 대상 변수의 행렬을 만듭니다.
데이터의 초기 모습은 다음과 같습니다.
In[]:
X = dataset.iloc[:, 3:13].values
Y = dataset.iloc[:, 13].values
X
산출
3 단계
Y
산출
array([1, 0, 1, ..., 1, 1, 0], dtype = int64)
4 단계
문자열 변수를 인코딩하여 분석을 더 간단하게 만듭니다. ScikitLearn 함수 'LabelEncoder'를 사용하여 0에서 n_classes-1 사이의 값으로 열의 다른 레이블을 자동으로 인코딩합니다.
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X_1 = LabelEncoder()
X[:,1] = labelencoder_X_1.fit_transform(X[:,1])
labelencoder_X_2 = LabelEncoder()
X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2])
X
산출
위 출력에서 국가 이름은 0, 1 및 2로 대체됩니다. 남성과 여성은 0과 1로 대체됩니다.
5 단계
Labelling Encoded Data
우리는 같은 것을 사용합니다 ScikitLearn 라이브러리 및 OneHotEncoder 더미 변수를 생성하는 열 번호를 전달합니다.
onehotencoder = OneHotEncoder(categorical features = [1])
X = onehotencoder.fit_transform(X).toarray()
X = X[:, 1:]
X
이제 처음 2 개 열은 국가를 나타내고 4 번째 열은 성별을 나타냅니다.
산출
우리는 항상 데이터를 교육 및 테스트 부분으로 나눕니다. 훈련 데이터에 대해 모델을 훈련 한 다음 모델의 효율성을 평가하는 데 도움이되는 테스트 데이터에서 모델의 정확성을 확인합니다.
6 단계
우리는 ScikitLearn의 train_test_split데이터를 훈련 세트와 테스트 세트로 분할하는 함수입니다. 학습 대 테스트 분할 비율을 80:20으로 유지합니다.
#Splitting the dataset into the Training set and the Test Set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)
일부 변수에는 수천 개의 값이 있고 일부는 수십 또는 1의 값이 있습니다. 데이터를 더 잘 대표 할 수 있도록 확장합니다.
7 단계
이 코드에서는 다음을 사용하여 훈련 데이터를 맞추고 변환합니다. StandardScaler함수. 스케일링을 표준화하여 테스트 데이터를 변환 / 스케일링하는 데 동일한 적합 방법을 사용합니다.
# Feature Scaling
fromsklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
산출
이제 데이터의 크기가 적절하게 조정되었습니다. 마지막으로 데이터 전처리가 완료되었습니다. 이제 모델부터 시작하겠습니다.
8 단계
여기에서 필요한 모듈을 가져옵니다. 신경망을 초기화하기위한 Sequential 모듈과 히든 레이어를 추가하기위한 조밀 모듈이 필요합니다.
# Importing the Keras libraries and packages
import keras
from keras.models import Sequential
from keras.layers import Dense
9 단계
고객 이탈을 분류하는 것이 목표이므로 모델 이름을 분류 자 (Classifier)로 지정하겠습니다. 그런 다음 초기화를 위해 Sequential 모듈을 사용합니다.
#Initializing Neural Network
classifier = Sequential()
10 단계
고밀도 기능을 사용하여 숨겨진 레이어를 하나씩 추가합니다. 아래 코드에서 많은 인수를 볼 수 있습니다.
첫 번째 매개 변수는 output_dim. 이 레이어에 추가하는 노드의 수입니다.initStochastic Gradient Decent의 초기화입니다. 신경망에서는 각 노드에 가중치를 할당합니다. 초기화시 가중치는 0에 가까워 야하며 uniform 함수를 사용하여 무작위로 가중치를 초기화합니다. 그만큼input_dim모델이 입력 변수의 수를 모르기 때문에 매개 변수는 첫 번째 계층에만 필요합니다. 여기서 입력 변수의 총 개수는 11 개입니다. 두 번째 레이어에서 모델은 첫 번째 은닉 레이어의 입력 변수 개수를 자동으로 인식합니다.
다음 코드 줄을 실행하여 입력 레이어와 첫 번째 숨겨진 레이어를 추가합니다.
classifier.add(Dense(units = 6, kernel_initializer = 'uniform',
activation = 'relu', input_dim = 11))
두 번째 숨겨진 레이어를 추가하려면 다음 코드 줄을 실행하십시오.
classifier.add(Dense(units = 6, kernel_initializer = 'uniform',
activation = 'relu'))
다음 코드 줄을 실행하여 출력 레이어를 추가합니다.
classifier.add(Dense(units = 1, kernel_initializer = 'uniform',
activation = 'sigmoid'))
11 단계
Compiling the ANN
지금까지 분류기에 여러 레이어를 추가했습니다. 이제 다음을 사용하여 컴파일합니다.compile방법. 최종 컴파일 제어에 추가 된 인수는 신경망을 완성하므로이 단계에서주의해야합니다.
다음은 인수에 대한 간략한 설명입니다.
첫 번째 주장은 Optimizer최적의 가중치 집합을 찾는 데 사용되는 알고리즘입니다. 이 알고리즘을Stochastic Gradient Descent (SGD). 여기서는 'Adam Optimizer'라는 여러 유형 중 하나를 사용합니다. SGD는 손실에 따라 달라 지므로 두 번째 매개 변수는 손실입니다. 종속 변수가 이진수이면 로그 손실 함수를 사용합니다.‘binary_crossentropy’, 종속 변수에 출력에 세 개 이상의 범주가있는 경우 다음을 사용합니다. ‘categorical_crossentropy’. 우리는 다음을 기반으로 신경망의 성능을 향상시키고 싶습니다.accuracy, 그래서 우리는 metrics 정확성으로.
# Compiling Neural Network
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
12 단계
이 단계에서 여러 코드를 실행해야합니다.
ANN을 교육 세트에 맞추기
이제 훈련 데이터에서 모델을 훈련합니다. 우리는fit우리 모델에 맞는 방법. 또한 가중치를 최적화하여 모델 효율성을 개선합니다. 이를 위해 가중치를 업데이트해야합니다.Batch size 가중치를 업데이트 한 후 관측 값의 수입니다. Epoch총 반복 횟수입니다. 배치 크기 및 에포크 값은 시행 착오 방법으로 선택됩니다.
classifier.fit(X_train, y_train, batch_size = 10, epochs = 50)
예측 및 모델 평가
# Predicting the Test set results
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)
하나의 새로운 관찰 예측
# Predicting a single new observation
"""Our goal is to predict if the customer with the following data will leave the bank:
Geography: Spain
Credit Score: 500
Gender: Female
Age: 40
Tenure: 3
Balance: 50000
Number of Products: 2
Has Credit Card: Yes
Is Active Member: Yes
13 단계
Predicting the test set result
예측 결과는 고객이 회사를 떠날 확률을 제공합니다. 이 확률을 이진수 0과 1로 변환합니다.
# Predicting the Test set results
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)
new_prediction = classifier.predict(sc.transform
(np.array([[0.0, 0, 500, 1, 40, 3, 50000, 2, 1, 1, 40000]])))
new_prediction = (new_prediction > 0.5)
14 단계
이것은 모델 성능을 평가하는 마지막 단계입니다. 우리는 이미 원래의 결과를 가지고 있으므로 모델의 정확성을 확인하기 위해 혼동 행렬을 만들 수 있습니다.
Making the Confusion Matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
print (cm)
산출
loss: 0.3384 acc: 0.8605
[ [1541 54]
[230 175] ]
혼동 행렬에서 모델의 정확도는 다음과 같이 계산할 수 있습니다.
Accuracy = 1541+175/2000=0.858
We achieved 85.8% accuracy, 어느 것이 좋니.
순방향 전파 알고리즘
이 섹션에서는 간단한 신경망에 대해 순방향 전파 (예측)를 수행하는 코드를 작성하는 방법을 배웁니다.
각 데이터 포인트는 고객입니다. 첫 번째 입력은 보유한 계정 수이고 두 번째 입력은 보유한 자녀 수입니다. 이 모델은 사용자가 내년에 얼마나 많은 트랜잭션을 수행하는지 예측합니다.
입력 데이터는 입력 데이터로 미리로드되고 가중치는 가중치라는 사전에 있습니다. 히든 레이어의 첫 번째 노드에 대한 가중치 배열은 가중치 [ 'node_0']에 있고 히든 레이어의 두 번째 노드에 대한 가중치 배열은 각각 가중치 [ 'node_1']에 있습니다.
출력 노드에 공급되는 가중치는 가중치로 사용할 수 있습니다.
정류 된 선형 활성화 기능
"활성화 기능"은 각 노드에서 작동하는 기능입니다. 노드의 입력을 일부 출력으로 변환합니다.
정류 된 선형 활성화 함수 ( ReLU 라고 함 )는 고성능 네트워크에서 널리 사용됩니다. 이 함수는 단일 숫자를 입력으로 사용하여 입력이 음수이면 0을 반환하고 입력이 양수이면 출력으로 입력합니다.
다음은 몇 가지 예입니다.
- relu (4) = 4
- relu (-2) = 0
relu () 함수의 정의를 채 웁니다.
- relu ()의 출력 값을 계산하기 위해 max () 함수를 사용합니다.
- relu () 함수를 node_0_input에 적용하여 node_0_output을 계산합니다.
- relu () 함수를 node_1_input에 적용하여 node_1_output을 계산합니다.
import numpy as np
input_data = np.array([-1, 2])
weights = {
'node_0': np.array([3, 3]),
'node_1': np.array([1, 5]),
'output': np.array([2, -1])
}
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = np.tanh(node_0_input)
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = np.tanh(node_1_input)
hidden_layer_output = np.array(node_0_output, node_1_output)
output =(hidden_layer_output * weights['output']).sum()
print(output)
def relu(input):
'''Define your relu activation function here'''
# Calculate the value for the output of the relu function: output
output = max(input,0)
# Return the value just calculated
return(output)
# Calculate node 0 value: node_0_output
node_0_input = (input_data * weights['node_0']).sum()
node_0_output = relu(node_0_input)
# Calculate node 1 value: node_1_output
node_1_input = (input_data * weights['node_1']).sum()
node_1_output = relu(node_1_input)
# Put node values into array: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])
# Calculate model output (do not apply relu)
odel_output = (hidden_layer_outputs * weights['output']).sum()
print(model_output)# Print model output
산출
0.9950547536867305
-3
많은 관찰 / 데이터 행에 네트워크 적용
이 섹션에서는 predict_with_network ()라는 함수를 정의하는 방법을 배웁니다. 이 함수는 위의 네트워크에서 input_data로 가져온 여러 데이터 관찰에 대한 예측을 생성합니다. 위의 네트워크에 주어진 가중치가 사용됩니다. relu () 함수 정의도 사용됩니다.
두 개의 인수 (input_data_row 및 weights)를 받아들이고 네트워크에서 예측값을 출력으로 반환하는 predict_with_network ()라는 함수를 정의 해 보겠습니다.
각 노드의 입력 및 출력 값을 계산하여 node_0_input, node_0_output, node_1_input 및 node_1_output으로 저장합니다.
노드의 입력 값을 계산하기 위해 관련 배열을 곱하고 합계를 계산합니다.
노드의 출력 값을 계산하기 위해 노드의 입력 값에 relu () 함수를 적용합니다. input_data를 반복하기 위해 'for 루프'를 사용합니다.
또한 우리는 predict_with_network ()를 사용하여 input_data-input_data_row의 각 행에 대한 예측을 생성합니다. 또한 각 예측을 결과에 추가합니다.
# Define predict_with_network()
def predict_with_network(input_data_row, weights):
# Calculate node 0 value
node_0_input = (input_data_row * weights['node_0']).sum()
node_0_output = relu(node_0_input)
# Calculate node 1 value
node_1_input = (input_data_row * weights['node_1']).sum()
node_1_output = relu(node_1_input)
# Put node values into array: hidden_layer_outputs
hidden_layer_outputs = np.array([node_0_output, node_1_output])
# Calculate model output
input_to_final_layer = (hidden_layer_outputs*weights['output']).sum()
model_output = relu(input_to_final_layer)
# Return model output
return(model_output)
# Create empty list to store prediction results
results = []
for input_data_row in input_data:
# Append prediction to results
results.append(predict_with_network(input_data_row, weights))
print(results)# Print results
산출
[0, 12]
여기서는 relu (26) = 26이고 relu (-13) = 0 등등 인 relu 함수를 사용했습니다.
심층 다층 신경망
여기에서는 두 개의 은닉 계층이있는 신경망에 대해 순방향 전파를 수행하는 코드를 작성합니다. 각 숨겨진 레이어에는 두 개의 노드가 있습니다. 입력 데이터는 다음과 같이 미리로드되었습니다.input_data. 첫 번째 숨겨진 레이어의 노드는 node_0_0 및 node_0_1이라고합니다.
가중치는 각각 가중치 [ 'node_0_0'] 및 가중치 [ 'node_0_1']로 미리로드됩니다.
두 번째 숨겨진 레이어의 노드는 node_1_0 and node_1_1. 무게는 다음과 같이 미리로드됩니다.weights['node_1_0'] 과 weights['node_1_1'] 각기.
그런 다음 미리로드 된 가중치를 사용하여 숨겨진 노드에서 모델 출력을 생성합니다. weights['output'].
가중치 가중치 [ 'node_0_0']와 주어진 input_data를 사용하여 node_0_0_input을 계산합니다. 그런 다음 relu () 함수를 적용하여 node_0_0_output을 가져옵니다.
node_0_1_input에 대해 위와 동일하게 node_0_1_output을 얻습니다.
가중치 가중치 [ 'node_1_0']와 첫 번째 숨겨진 레이어의 출력 인 hidden_0_outputs를 사용하여 node_1_0_input을 계산합니다. 그런 다음 relu () 함수를 적용하여 node_1_0_output을 얻습니다.
node_1_1_input에 대해 위와 동일하게 node_1_1_output을 얻습니다.
weights [ 'output']과 두 번째 은닉층 hidden_1_outputs 배열의 출력을 사용하여 model_output을 계산합니다. 이 출력에는 relu () 함수를 적용하지 않습니다.
import numpy as np
input_data = np.array([3, 5])
weights = {
'node_0_0': np.array([2, 4]),
'node_0_1': np.array([4, -5]),
'node_1_0': np.array([-1, 1]),
'node_1_1': np.array([2, 2]),
'output': np.array([2, 7])
}
def predict_with_network(input_data):
# Calculate node 0 in the first hidden layer
node_0_0_input = (input_data * weights['node_0_0']).sum()
node_0_0_output = relu(node_0_0_input)
# Calculate node 1 in the first hidden layer
node_0_1_input = (input_data*weights['node_0_1']).sum()
node_0_1_output = relu(node_0_1_input)
# Put node values into array: hidden_0_outputs
hidden_0_outputs = np.array([node_0_0_output, node_0_1_output])
# Calculate node 0 in the second hidden layer
node_1_0_input = (hidden_0_outputs*weights['node_1_0']).sum()
node_1_0_output = relu(node_1_0_input)
# Calculate node 1 in the second hidden layer
node_1_1_input = (hidden_0_outputs*weights['node_1_1']).sum()
node_1_1_output = relu(node_1_1_input)
# Put node values into array: hidden_1_outputs
hidden_1_outputs = np.array([node_1_0_output, node_1_1_output])
# Calculate model output: model_output
model_output = (hidden_1_outputs*weights['output']).sum()
# Return model_output
return(model_output)
output = predict_with_network(input_data)
print(output)
산출
364