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)のマトリックスを作成し、「Exited」というラベルを付けます。

データの初期の外観は次のとおりです-

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

顧客離れを分類することを目的としているため、モデルに分類子という名前を付けます。次に、初期化にSequentialモジュールを使用します。

#Initializing Neural Network 
classifier = Sequential()

ステップ10

密関数を使用して、非表示のレイヤーを1つずつ追加します。以下のコードでは、多くの引数が表示されます。

最初のパラメータは output_dim。これは、このレイヤーに追加するノードの数です。init確率的勾配降下法の初期化です。ニューラルネットワークでは、各ノードに重みを割り当てます。初期化時には、重みはゼロに近いはずであり、均一関数を使用して重みをランダムに初期化します。ザ・input_dimモデルは入力変​​数の数を認識していないため、パラメーターは最初のレイヤーにのみ必要です。ここで、入力変数の総数は11です。2番目の層では、モデルは最初の非表示層からの入力変数の数を自動的に認識します。

次のコード行を実行して、入力レイヤーと最初の非表示レイヤーを追加します-

classifier.add(Dense(units = 6, kernel_initializer = 'uniform', 
activation = 'relu', input_dim = 11))

次のコード行を実行して、2番目の隠れ層を追加します-

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)。ここでは、「アダムオプティマイザー」と呼ばれるいくつかのタイプの1つを使用しています。SGDは損失に依存するため、2番目のパラメーターは損失です。従属変数がバイナリの場合、次の対数損失関数を使用します。‘binary_crossentropy’、および従属変数の出力に3つ以上のカテゴリがある場合は、 ‘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、 どっちがいい。

順伝播アルゴリズム

このセクションでは、単純なニューラルネットワークの順伝播(予測)を行うためのコードの記述方法を学習します。

各データポイントは顧客です。最初の入力はアカウントの数であり、2番目の入力は子の数です。このモデルは、ユーザーが翌年に行うトランザクションの数を予測します。

入力データは入力データとしてプリロードされ、重みは重みと呼ばれる辞書にあります。隠れ層の最初のノードの重みの配列は重み['node_0']であり、隠れ層の2番目のノードの重みの配列はそれぞれ重み['node_1']です。

出力ノードに供給される重みは、重みで使用できます。

正規化線形活性化関数

「活性化関数」とは、各ノードで機能する関数です。ノードの入力を何らかの出力に変換します。

正規化線形活性化関数(ReLUと呼ばれる)は、非常に高性能なネットワークで広く使用されています。この関数は、単一の数値を入力として受け取り、入力が負の場合は0を返し、入力が正の場合は出力として入力を返します。

ここにいくつかの例があります-

  • relu(4)= 4
  • relu(-2)= 0

relu()関数の定義を入力します-

  • max()関数を使用して、relu()の出力の値を計算します。
  • 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()関数の定義も使用されています。

2つの引数(input_data_rowとweights)を受け入れ、ネットワークからの予測を出力として返すpredict_with_network()という関数を定義しましょう。

各ノードの入力値と出力値を計算し、node_0_input、node_0_output、node_1_input、およびnode_1_outputとして保存します。

ノードの入力値を計算するには、関連する配列を乗算し、それらの合計を計算します。

ノードの出力値を計算するには、relu()関数をノードの入力値に適用します。'forループ'を使用してinput_dataを反復処理します-

また、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関数を使用しました。

深い多層ニューラルネットワーク

ここでは、2つの隠れ層を持つニューラルネットワークの順伝播を行うコードを記述しています。各隠れ層には2つのノードがあります。入力データは次のようにプリロードされていますinput_data。最初の隠れ層のノードは、node_0_0およびnode_0_1と呼ばれます。

それらの重みは、それぞれweights ['node_0_0']およびweights ['node_0_1']としてプリロードされています。

2番目の隠れ層のノードは呼び出されます node_1_0 and node_1_1。それらの重みは次のように事前にロードされていますweights['node_1_0'] そして weights['node_1_1'] それぞれ。

次に、次のようにプリロードされた重みを使用して、非表示ノードからモデル出力を作成します。 weights['output']

node_0_0_inputは、その重みweights ['node_0_0']と指定されたinput_dataを使用して計算します。次に、relu()関数を適用してnode_0_0_outputを取得します。

node_0_1_inputに対して上記と同じことを行い、node_0_1_outputを取得します。

node_1_0_inputは、その重みweights ['node_1_0']と最初の隠れ層からの出力(hidden_​​0_outputs)を使用して計算します。次に、relu()関数を適用してnode_1_0_outputを取得します。

node_1_1_inputに対して上記と同じことを行い、node_1_1_outputを取得します。

weights ['output']と2番目の隠れ層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