Python-deep-learning-implementations

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

出力

Step4 Output

上記の出力では、国名は0、1、および2に置き換えられています。一方、男性と女性は0と1に置き換えられます。

ステップ5

エンコードされたデータのラベル付け

同じ ScikitLearn ライブラリと OneHotEncoder と呼ばれる別の関数を使用して、ダミー変数を作成する列番号を渡すだけです。

onehotencoder = OneHotEncoder(categorical features = [1])
X = onehotencoder.fit_transform(X).toarray()
X = X[:, 1:]
X

現在、最初の2列は国を表し、4列目は性別を表しています。

出力

Step5 Output

データは常にトレーニングとテストの部分に分けられます。トレーニングデータでモデルをトレーニングし、テストデータでモデルの精度をチェックします。これは、モデルの効率を評価するのに役立ちます。

ステップ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)

出力

step7 output

これで、データが適切にスケーリングされました。 最後に、データの前処理が完了しました。 次に、モデルから始めます。

ステップ8

ここで必要なモジュールをインポートします。 ニューラルネットワークを初期化するシーケンシャルモジュールと、隠れ層を追加する高密度モジュールが必要です。

# 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

dense関数を使用して、隠れ層を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

• ANNのコンパイル *

これまで、分類器に複数のレイヤーを追加しました。* compile *メソッドを使用してそれらをコンパイルします。 最終的なコンパイル制御で追加された引数により、ニューラルネットワークが完成します。そのため、このステップでは注意が必要です。

以下に、引数の簡単な説明を示します。

最初の引数は Optimizer です。これは、最適な重みのセットを見つけるために使用されるアルゴリズムです。 このアルゴリズムは、確率的勾配降下（SGD）*と呼ばれます。 ここでは、「アダムオプティマイザー」と呼ばれるいくつかのタイプの1つを使用しています。 SGDは損失に依存するため、2番目のパラメーターは損失です。 従属変数がバイナリの場合、 *'binary_crossentropy' と呼ばれる対数損失関数を使用し、従属変数の出力に3つ以上のカテゴリがある場合、 'categorical_crossentropy' を使用します。 *精度*に基づいてニューラルネットワークのパフォーマンスを改善したいので、精度として*メトリック*を追加します。

# Compiling Neural Network
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

手順12

このステップでは、多くのコードを実行する必要があります。

ANNをトレーニングセットに適合させる

次に、トレーニングデータでモデルをトレーニングします。 fit メソッドを使用してモデルを近似します。 また、モデルの効率を改善するために重みを最適化します。 このためには、重みを更新する必要があります。 バッチサイズ*は、重みを更新した後の観測数です。 *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

テストセットの結果の予測

予測結果は、顧客が会社を去る確率を提供します。 その確率をバイナリの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([[new_prediction = (new_prediction > 0.5)

ステップ14

これは、モデルのパフォーマンスを評価する最後のステップです。 すでに元の結果が得られているため、混同マトリックスを作成して、モデルの精度を確認できます。

混同マトリックスの作成

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

• 85.8％の精度*を達成しました。これは良いことです。

前方伝播アルゴリズム

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

前方伝播アルゴリズム

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

入力データは入力データとしてプリロードされ、重みは重みと呼ばれる辞書にあります。 隠れ層の最初のノードの重みの配列は重み['node_0']にあり、隠れ層の2番目のノードの重みの配列はそれぞれweights ['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（）関数を適用します。 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関数を使用しました。

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

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

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

2番目の非表示層のノードは、 node_1_0およびnode_1_1 と呼ばれます。 それらの重みは、それぞれ weights ['node_1_0'] および weights ['node_1_1'] としてプリロードされています。

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

Deep Multi Layer

その重みweights ['node_0_0']と与えられたinput_dataを使用してnode_0_0_inputを計算します。 次に、relu（）関数を適用してnode_0_0_outputを取得します。

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

その重みweights ['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']と2番目のhidden層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