Python Deep Learning - Implementasi

Dalam penerapan Deep Learning ini, tujuan kami adalah untuk memprediksi penarikan atau pengadukan data nasabah untuk bank tertentu - nasabah mana yang kemungkinan besar akan meninggalkan layanan bank ini. Set data yang digunakan relatif kecil dan berisi 10.000 baris dengan 14 kolom. Kami menggunakan distribusi Anaconda, dan kerangka kerja seperti Theano, TensorFlow, dan Keras. Keras dibangun di atas Tensorflow dan Theano yang berfungsi sebagai backend-nya.

# Artificial Neural Network
# Installing Theano
pip install --upgrade theano

# Installing Tensorflow
pip install –upgrade tensorflow

# Installing Keras
pip install --upgrade keras

Langkah 1: Pemrosesan awal data

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')

Langkah 2

Kami membuat matriks dari fitur set data dan variabel target, yaitu kolom 14, diberi label sebagai "Keluar".

Tampilan awal data adalah seperti di bawah ini -

In[]:
X = dataset.iloc[:, 3:13].values
Y = dataset.iloc[:, 13].values
X

Keluaran

LANGKAH 3

Keluaran

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

LANGKAH 4

Kami membuat analisis lebih sederhana dengan mengkodekan variabel string. Kami menggunakan fungsi ScikitLearn 'LabelEncoder' untuk secara otomatis menyandikan label yang berbeda di kolom dengan nilai antara 0 hingga 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

Keluaran

Pada keluaran di atas, nama negara diganti dengan 0, 1 dan 2; sedangkan pria dan wanita diganti dengan 0 dan 1.

LANGKAH 5

Labelling Encoded Data

Kami menggunakan yang sama ScikitLearn perpustakaan dan fungsi lain yang disebut OneHotEncoder untuk hanya melewatkan nomor kolom membuat variabel dummy.

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

Sekarang, 2 kolom pertama mewakili negara dan kolom ke-4 mewakili jenis kelamin.

Keluaran

Kami selalu membagi data kami menjadi bagian pelatihan dan pengujian; kami melatih model kami pada data pelatihan dan kemudian kami memeriksa keakuratan model pada data pengujian yang membantu dalam mengevaluasi efisiensi model.

LANGKAH 6

Kami menggunakan ScikitLearn's train_test_splitberfungsi untuk membagi data kita menjadi set pelatihan dan set pengujian. Kami mempertahankan rasio pemisahan kereta-ke-tes sebagai 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)

Beberapa variabel memiliki nilai dalam ribuan sementara beberapa memiliki nilai dalam puluhan atau satu. Kami menskalakan data agar lebih representatif.

LANGKAH 7

Dalam kode ini, kami menyesuaikan dan mengubah data pelatihan menggunakan StandardScalerfungsi. Kami menstandarkan penskalaan kami sehingga kami menggunakan metode pas yang sama untuk mengubah / menskalakan data uji.

# Feature Scaling

fromsklearn.preprocessing import StandardScaler 
sc = StandardScaler() 
X_train = sc.fit_transform(X_train) 
X_test = sc.transform(X_test)

Keluaran

Data sekarang diskalakan dengan benar. Akhirnya, kami selesai dengan pemrosesan awal data kami. Sekarang, kita akan mulai dengan model kita.

LANGKAH 8

Kami mengimpor Modul yang diperlukan di sini. Kita membutuhkan modul Sequential untuk menginisialisasi jaringan saraf dan modul padat untuk menambahkan lapisan tersembunyi.

# Importing the Keras libraries and packages 
import keras 
from keras.models import Sequential 
from keras.layers import Dense

LANGKAH 9

Kami akan menamai model tersebut sebagai Pengklasifikasi karena tujuan kami adalah untuk mengklasifikasikan churn pelanggan. Kemudian kami menggunakan modul Sequential untuk inisialisasi.

#Initializing Neural Network 
classifier = Sequential()

LANGKAH 10

Kami menambahkan lapisan tersembunyi satu per satu menggunakan fungsi padat. Pada kode di bawah ini, kita akan melihat banyak argumen.

Parameter pertama kami adalah output_dim. Ini adalah jumlah node yang kami tambahkan ke lapisan ini.initadalah inisialisasi dari Stochastic Gradient Decent. Dalam Jaringan Neural kami menetapkan bobot untuk setiap node. Saat inisialisasi, bobot harus mendekati nol dan kami menginisialisasi bobot secara acak menggunakan fungsi seragam. Ituinput_dimparameter hanya diperlukan untuk lapisan pertama, karena model tidak mengetahui jumlah variabel masukan kita. Di sini jumlah total variabel masukan adalah 11. Pada lapisan kedua, model secara otomatis mengetahui jumlah variabel masukan dari lapisan tersembunyi pertama.

Jalankan baris kode berikut untuk menambahkan lapisan masukan dan lapisan tersembunyi pertama -

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

Jalankan baris kode berikut untuk menambahkan lapisan tersembunyi kedua -

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

Jalankan baris kode berikut untuk menambahkan lapisan keluaran -

classifier.add(Dense(units = 1, kernel_initializer = 'uniform', 
activation = 'sigmoid'))

LANGKAH 11

Compiling the ANN

Kami telah menambahkan beberapa lapisan ke pengklasifikasi kami sampai sekarang. Kami sekarang akan mengkompilasinya menggunakancompilemetode. Argumen yang ditambahkan dalam kontrol kompilasi akhir melengkapi jaringan neural. Jadi, kita perlu berhati-hati dalam langkah ini.

Berikut penjelasan singkat tentang dalil-dalil tersebut.

Argumen pertama adalah OptimizerIni adalah algoritma yang digunakan untuk menemukan set bobot yang optimal. Algoritma ini disebutStochastic Gradient Descent (SGD). Di sini kami menggunakan satu di antara beberapa jenis, yang disebut 'pengoptimal Adam'. SGD tergantung pada kerugian, jadi parameter kedua kita adalah kerugian. Jika variabel dependen kami adalah biner, kami menggunakan fungsi kerugian logaritmik yang disebut‘binary_crossentropy’, dan jika variabel dependen kami memiliki lebih dari dua kategori dalam output, maka kami menggunakan ‘categorical_crossentropy’. Kami ingin meningkatkan kinerja jaringan saraf kami berdasarkanaccuracy, jadi kami menambahkan metrics sebagai akurasi.

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

LANGKAH 12

Sejumlah kode perlu dijalankan pada langkah ini.

Memasang JST ke Set Pelatihan

Kami sekarang melatih model kami pada data pelatihan. Kami menggunakanfitmetode agar sesuai dengan model kami. Kami juga mengoptimalkan anak timbangan untuk meningkatkan efisiensi model. Untuk ini, kami harus memperbarui bobot.Batch size adalah jumlah observasi setelah kami memperbarui bobot. Epochadalah jumlah total iterasi. Nilai ukuran batch dan epoch dipilih dengan metode trial and error.

classifier.fit(X_train, y_train, batch_size = 10, epochs = 50)

Membuat prediksi dan mengevaluasi model

# Predicting the Test set results
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)

Memprediksi satu observasi baru

# 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

LANGKAH 13

Predicting the test set result

Hasil prediksi akan memberikan kemungkinan pelanggan keluar dari perusahaan. Kami akan mengubah probabilitas itu menjadi biner 0 dan 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)

LANGKAH 14

Ini adalah langkah terakhir di mana kami mengevaluasi kinerja model kami. Kami sudah memiliki hasil asli dan dengan demikian kami dapat membuat matriks kebingungan untuk memeriksa keakuratan model kami.

Making the Confusion Matrix

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
print (cm)

Keluaran

loss: 0.3384 acc: 0.8605
[ [1541 54]
[230 175] ]

Dari matriks kebingungan, Akurasi model kami dapat dihitung sebagai -

Accuracy = 1541+175/2000=0.858

We achieved 85.8% accuracy, yang mana yang bagus.

Algoritma Propagasi Maju

Di bagian ini, kita akan belajar bagaimana menulis kode untuk melakukan propagasi maju (prediksi) untuk jaringan saraf sederhana -

Setiap titik data adalah pelanggan. Input pertama adalah berapa akun yang mereka miliki, dan input kedua adalah berapa anak yang mereka miliki. Model tersebut akan memprediksi berapa banyak transaksi yang dilakukan pengguna di tahun depan.

Data masukan dimuat sebelumnya sebagai data masukan, dan bobot ada dalam kamus yang disebut bobot. Larik bobot untuk node pertama di lapisan tersembunyi berada dalam bobot ['node_0'], dan untuk node kedua di lapisan tersembunyi masing-masing dalam bobot ['node_1'].

Bobot yang dimasukkan ke dalam node keluaran tersedia dalam bobot.

Fungsi Aktivasi Linear yang Diperbaiki

Sebuah "fungsi aktivasi" adalah fungsi yang bekerja di setiap node. Ini mengubah masukan node menjadi beberapa keluaran.

Fungsi aktivasi linier yang diperbaiki (disebut ULT ) banyak digunakan di jaringan berkinerja sangat tinggi. Fungsi ini mengambil satu angka sebagai masukan, mengembalikan 0 jika masukan negatif, dan masukan sebagai keluaran jika masukan positif.

Berikut beberapa contoh -

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

Kami mengisi definisi dari relu () function−

Kami menggunakan fungsi max () untuk menghitung nilai output relu ().
Kami menerapkan fungsi relu () ke node_0_input untuk menghitung node_0_output.
Kami menerapkan fungsi relu () ke node_1_input untuk menghitung 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

Keluaran

0.9950547536867305
-3

Menerapkan jaringan ke banyak Pengamatan / baris data

Di bagian ini, kita akan belajar bagaimana mendefinisikan sebuah fungsi yang disebut predict_with_network (). Fungsi ini akan menghasilkan prediksi untuk beberapa observasi data, diambil dari jaringan di atas yang diambil sebagai input_data. Bobot yang diberikan dalam jaringan di atas sedang digunakan. Definisi fungsi relu () juga digunakan.

Mari kita definisikan fungsi yang disebut predict_with_network () yang menerima dua argumen - input_data_row dan bobot - dan mengembalikan prediksi dari jaringan sebagai keluaran.

Kami menghitung nilai input dan output untuk setiap node, menyimpannya sebagai: node_0_input, node_0_output, node_1_input, dan node_1_output.

Untuk menghitung nilai input dari sebuah node, kami mengalikan array yang relevan bersama-sama dan menghitung jumlahnya.

Untuk menghitung nilai keluaran dari sebuah node, kami menerapkan fungsi relu () ke nilai input dari node tersebut. Kami menggunakan 'for loop' untuk mengulang input_data -

Kami juga menggunakan predict_with_network () untuk menghasilkan prediksi untuk setiap baris input_data - input_data_row. Kami juga menambahkan setiap prediksi ke hasil.

# 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

Keluaran

[0, 12]

Di sini kita telah menggunakan fungsi relu di mana relu (26) = 26 dan relu (-13) = 0 dan seterusnya.

Jaringan neural multi-lapisan dalam

Di sini kami menulis kode untuk melakukan propagasi maju untuk jaringan saraf dengan dua lapisan tersembunyi. Setiap lapisan tersembunyi memiliki dua node. Data masukan telah dimuat sebelumnya sebagaiinput_data. Node di lapisan tersembunyi pertama disebut node_0_0 dan node_0_1.

Bobot mereka dimuat sebelumnya sebagai bobot ['node_0_0'] dan bobot ['node_0_1'].

Node di lapisan tersembunyi kedua dipanggil node_1_0 and node_1_1. Bobot mereka telah dimuat sebelumnya sebagaiweights['node_1_0'] dan weights['node_1_1'] masing-masing.

Kami kemudian membuat keluaran model dari node tersembunyi menggunakan bobot yang dimuat sebelumnya sebagai weights['output'].

Kami menghitung node_0_0_input menggunakan bobot bobotnya ['node_0_0'] dan input_data yang diberikan. Kemudian terapkan fungsi relu () untuk mendapatkan node_0_0_output.

Kami melakukan hal yang sama seperti di atas untuk node_0_1_input untuk mendapatkan node_0_1_output.

Kami menghitung node_1_0_input menggunakan bobot bobotnya ['node_1_0'] dan keluaran dari lapisan tersembunyi pertama - hidden_0_outputs. Kami kemudian menerapkan fungsi relu () untuk mendapatkan node_1_0_output.

Kami melakukan hal yang sama seperti di atas untuk node_1_1_input untuk mendapatkan node_1_1_output.

Kami menghitung model_output menggunakan bobot ['output'] dan keluaran dari larik hidden_1_outputs lapisan tersembunyi kedua. Kami tidak menerapkan fungsi relu () ke output ini.

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)

Keluaran