Python Deep Learning - การนำไปใช้งาน

ในการนำ Deep learning ไปใช้นี้วัตถุประสงค์ของเราคือการคาดการณ์การขัดสีของลูกค้าหรือการเปลี่ยนข้อมูลของธนาคารบางแห่งซึ่งลูกค้ามีแนวโน้มที่จะออกจากบริการของธนาคารนี้ ชุดข้อมูลที่ใช้มีขนาดค่อนข้างเล็กและมี 10,000 แถว 14 คอลัมน์ เราใช้การแจกจ่าย 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)

ตัวแปรบางตัวมีค่าเป็นพันในขณะที่ตัวแปรบางตัวมีค่าเป็นหลักหมื่น เราปรับขนาดข้อมูลเพื่อให้เป็นตัวแทนมากขึ้น

ขั้นตอนที่ 7

ในรหัสนี้เรากำลังปรับและเปลี่ยนข้อมูลการฝึกอบรมโดยใช้ไฟล์ StandardScalerฟังก์ชัน เรากำหนดมาตราส่วนของเราให้เป็นมาตรฐานเพื่อให้เราใช้วิธีการติดตั้งแบบเดียวกันในการแปลง / ปรับขนาดข้อมูลทดสอบ

# Feature Scaling

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

เอาต์พุต

ขณะนี้ข้อมูลได้รับการปรับขนาดอย่างเหมาะสมแล้ว ในที่สุดเราก็ดำเนินการกับข้อมูลก่อนการประมวลผล ตอนนี้เราจะเริ่มต้นด้วยโมเดลของเรา

ขั้นตอนที่ 8

เรานำเข้าโมดูลที่จำเป็นที่นี่ เราต้องการโมดูลลำดับสำหรับการเริ่มต้นเครือข่ายประสาทเทียมและโมดูลหนาแน่นเพื่อเพิ่มเลเยอร์ที่ซ่อนอยู่

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

ขั้นตอนที่ 9

เราจะตั้งชื่อรุ่นว่า Classifier เนื่องจากจุดมุ่งหมายของเราคือการจัดประเภทการปั่นของลูกค้า จากนั้นเราใช้โมดูลลำดับสำหรับการเริ่มต้น

#Initializing Neural Network 
classifier = Sequential()

ขั้นตอนที่ 10

เราเพิ่มเลเยอร์ที่ซ่อนไว้ทีละชั้นโดยใช้ฟังก์ชันหนาแน่น ในโค้ดด้านล่างนี้เราจะเห็นอาร์กิวเมนต์มากมาย

พารามิเตอร์แรกของเราคือ output_dim. มันคือจำนวนโหนดที่เราเพิ่มในเลเยอร์นี้initคือการเริ่มต้นของ Stochastic Gradient Decent ใน Neural Network เรากำหนดน้ำหนักให้กับแต่ละโหนด ในการเริ่มต้นน้ำหนักควรอยู่ใกล้ศูนย์และเราสุ่มเริ่มต้นน้ำหนักโดยใช้ฟังก์ชันเครื่องแบบ 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 () −

• เราใช้ฟังก์ชัน 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 ()

ให้เรากำหนดฟังก์ชันที่เรียกว่า Predict_with_network () ที่ยอมรับสองอาร์กิวเมนต์ - input_data_row และ weights - และส่งคืนการคาดการณ์จากเครือข่ายเป็นผลลัพธ์

เราคำนวณค่าอินพุตและเอาต์พุตสำหรับแต่ละโหนดโดยจัดเก็บเป็น: node_0_input, node_0_output, node_1_input และ node_1_output

ในการคำนวณค่าอินพุตของโหนดเราจะคูณอาร์เรย์ที่เกี่ยวข้องเข้าด้วยกันและคำนวณผลรวม

ในการคำนวณค่าเอาต์พุตของโหนดเราใช้ฟังก์ชัน relu () กับค่าอินพุตของโหนด เราใช้ 'for loop' เพื่อวนซ้ำใน input_data -

เรายังใช้การคาดคะเน _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 โดยที่ relu (26) = 26 และ relu (-13) = 0 เป็นต้น

โครงข่ายประสาทเทียมหลายชั้นลึก

ที่นี่เรากำลังเขียนโค้ดเพื่อทำการขยายไปข้างหน้าสำหรับโครงข่ายประสาทเทียมที่มีเลเยอร์ซ่อนอยู่สองชั้น แต่ละชั้นที่ซ่อนมีสองโหนด ข้อมูลอินพุตถูกโหลดไว้ล่วงหน้าเป็น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 โดยใช้น้ำหนักของมัน ['node_0_0'] และ input_data ที่กำหนด จากนั้นใช้ฟังก์ชัน relu () เพื่อรับ node_0_0_output

เราทำเช่นเดียวกับด้านบนสำหรับ node_0_1_input เพื่อรับ node_0_1_output

เราคำนวณ node_1_0_input โดยใช้น้ำหนักของมัน ['node_1_0'] และผลลัพธ์จากเลเยอร์ที่ซ่อนแรก - hidden_0_outputs จากนั้นเราใช้ฟังก์ชัน relu () เพื่อรับ node_1_0_output

เราทำเช่นเดียวกับข้างต้นสำหรับ node_1_1_input เพื่อรับ node_1_1_output

เราคำนวณ model_output โดยใช้น้ำหนัก ['output'] และผลลัพธ์จากอาร์เรย์ hidden_1_outputs ชั้นที่สองที่ซ่อนอยู่ เราไม่ใช้ฟังก์ชัน 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