AI กับ Python - การเรียนรู้เชิงลึก

โครงข่ายประสาทเทียม (ANN) เป็นระบบคอมพิวเตอร์ที่มีประสิทธิภาพซึ่งมีธีมหลักที่ยืมมาจากการเปรียบเทียบเครือข่ายประสาททางชีววิทยา โครงข่ายประสาทเทียมเป็นแบบจำลองประเภทหนึ่งสำหรับการเรียนรู้ของเครื่อง ในช่วงกลางทศวรรษที่ 1980 และต้นทศวรรษที่ 1990 ความก้าวหน้าทางสถาปัตยกรรมที่สำคัญเกิดขึ้นในโครงข่ายประสาทเทียม ในบทนี้คุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับ Deep Learning ซึ่งเป็นแนวทางของ AI

การเรียนรู้เชิงลึกเกิดขึ้นจากการเติบโตด้านการคำนวณที่เพิ่มขึ้นอย่างรวดเร็วในช่วงทศวรรษที่ผ่านมาในฐานะคู่แข่งที่จริงจังในสาขานี้ ดังนั้นการเรียนรู้เชิงลึกจึงเป็นการเรียนรู้ของเครื่องประเภทหนึ่งซึ่งอัลกอริทึมได้รับแรงบันดาลใจจากโครงสร้างและหน้าที่ของสมองมนุษย์

การเรียนรู้ของเครื่อง v / s การเรียนรู้เชิงลึก

การเรียนรู้เชิงลึกเป็นเทคนิคการเรียนรู้ของเครื่องที่ทรงพลังที่สุดในปัจจุบัน มันมีพลังมากเพราะพวกเขาเรียนรู้วิธีที่ดีที่สุดในการเป็นตัวแทนของปัญหาในขณะที่เรียนรู้วิธีแก้ปัญหา การเปรียบเทียบการเรียนรู้เชิงลึกและการเรียนรู้ของเครื่องแสดงไว้ด้านล่าง -

การพึ่งพาข้อมูล

จุดแรกของความแตกต่างขึ้นอยู่กับประสิทธิภาพของ DL และ ML เมื่อขนาดของข้อมูลเพิ่มขึ้น เมื่อข้อมูลมีขนาดใหญ่อัลกอริทึมการเรียนรู้เชิงลึกจะทำงานได้ดีมาก

การพึ่งพาเครื่องจักร

อัลกอริธึมการเรียนรู้เชิงลึกจำเป็นต้องใช้เครื่องจักรระดับไฮเอนด์เพื่อให้ทำงานได้อย่างสมบูรณ์ ในทางกลับกันอัลกอริทึมการเรียนรู้ของเครื่องสามารถทำงานบนเครื่องระดับล่างได้เช่นกัน

คุณสมบัติการสกัด

อัลกอริทึมการเรียนรู้เชิงลึกสามารถดึงคุณสมบัติระดับสูงและพยายามเรียนรู้จากสิ่งเดียวกันได้เช่นกัน ในทางกลับกันผู้เชี่ยวชาญจะต้องระบุคุณลักษณะส่วนใหญ่ที่ดึงมาจากการเรียนรู้ของเครื่อง

เวลาดำเนินการ

เวลาดำเนินการขึ้นอยู่กับพารามิเตอร์จำนวนมากที่ใช้ในอัลกอริทึม การเรียนรู้เชิงลึกมีพารามิเตอร์มากกว่าอัลกอริทึมการเรียนรู้ของเครื่อง ดังนั้นเวลาดำเนินการของอัลกอริทึม DL โดยเฉพาะเวลาฝึกอบรมจึงมากกว่าอัลกอริทึม ML มาก แต่เวลาในการทดสอบอัลกอริทึม DL น้อยกว่าอัลกอริทึม ML

แนวทางในการแก้ปัญหา

การเรียนรู้เชิงลึกช่วยแก้ปัญหาแบบ end-to-end ในขณะที่การเรียนรู้ของเครื่องใช้วิธีการแก้ปัญหาแบบดั้งเดิมเช่นการแยกย่อยออกเป็นส่วน ๆ

Convolutional Neural Network (CNN)

โครงข่ายประสาทแบบ Convolutional นั้นเหมือนกับโครงข่ายประสาทธรรมดาเพราะประกอบด้วยเซลล์ประสาทที่มีน้ำหนักและอคติที่เรียนรู้ได้ โครงข่ายประสาทเทียมธรรมดาจะไม่สนใจโครงสร้างของข้อมูลอินพุตและข้อมูลทั้งหมดจะถูกแปลงเป็นอาร์เรย์ 1-D ก่อนที่จะป้อนเข้าในเครือข่าย กระบวนการนี้เหมาะกับข้อมูลทั่วไปอย่างไรก็ตามหากข้อมูลมีรูปภาพกระบวนการอาจยุ่งยาก

CNN แก้ปัญหานี้ได้อย่างง่ายดาย ต้องคำนึงถึงโครงสร้าง 2 มิติของภาพเมื่อประมวลผลซึ่งช่วยให้สามารถดึงคุณสมบัติเฉพาะของภาพออกมาได้ ด้วยวิธีนี้เป้าหมายหลักของ CNN คือการเปลี่ยนจากข้อมูลรูปภาพดิบในเลเยอร์อินพุตไปยังคลาสที่ถูกต้องในเลเยอร์เอาต์พุต ความแตกต่างเพียงอย่างเดียวระหว่าง NN ธรรมดาและ CNN คือในการจัดการข้อมูลอินพุตและในประเภทของเลเยอร์

ภาพรวมสถาปัตยกรรมของ CNN

ในทางสถาปัตยกรรมเครือข่ายประสาทเทียมทั่วไปได้รับอินพุตและแปลงผ่านชุดของเลเยอร์ที่ซ่อนอยู่ ทุกชั้นเชื่อมต่อกับชั้นอื่น ๆ ด้วยความช่วยเหลือของเซลล์ประสาท ข้อเสียเปรียบหลักของโครงข่ายประสาทเทียมทั่วไปคือไม่สามารถปรับขนาดได้ดีจนเต็มภาพ

สถาปัตยกรรมของ CNN มีเซลล์ประสาทเรียงกันเป็น 3 มิติเรียกว่าความกว้างความสูงและความลึก เซลล์ประสาทแต่ละเซลล์ในชั้นปัจจุบันเชื่อมต่อกับส่วนเล็ก ๆ ของเอาต์พุตจากชั้นก่อนหน้า คล้ายกับการซ้อนทับไฟล์×กรองภาพอินพุต มันใช้Mตัวกรองเพื่อให้แน่ใจว่าได้รับรายละเอียดทั้งหมด เหล่านี้M ฟิลเตอร์เป็นตัวแยกคุณสมบัติที่ดึงคุณสมบัติต่างๆเช่นขอบมุม ฯลฯ

เลเยอร์ที่ใช้สร้าง CNN

ชั้นต่อไปนี้ใช้เพื่อสร้าง CNN -

• Input Layer - ใช้ข้อมูลภาพดิบตามที่เป็นจริง

• Convolutional Layer- เลเยอร์นี้เป็นส่วนประกอบหลักของ CNN ที่ทำหน้าที่คำนวณส่วนใหญ่ ชั้นนี้จะคำนวณการเปลี่ยนแปลงระหว่างเซลล์ประสาทและแพทช์ต่างๆในอินพุต

• Rectified Linear Unit Layer- ใช้ฟังก์ชันการเปิดใช้งานกับเอาต์พุตของเลเยอร์ก่อนหน้า เพิ่มความไม่เป็นเชิงเส้นให้กับเครือข่ายเพื่อให้สามารถสรุปได้ดีกับฟังก์ชันประเภทใด ๆ

• Pooling Layer- การรวมกลุ่มช่วยให้เราเก็บเฉพาะส่วนที่สำคัญเมื่อเราก้าวหน้าในเครือข่าย เลเยอร์พูลทำงานอย่างอิสระในทุกส่วนความลึกของอินพุตและปรับขนาดเชิงพื้นที่ ใช้ฟังก์ชัน MAX

• Fully Connected layer/Output layer - เลเยอร์นี้จะคำนวณคะแนนผลลัพธ์ในชั้นสุดท้าย ผลลัพธ์ที่ได้มีขนาด×× โดยที่ L คือคลาสชุดข้อมูลการฝึกอบรมจำนวน

การติดตั้งแพ็คเกจ Python ที่มีประโยชน์

คุณสามารถใช้ได้ Kerasซึ่งเป็น API เครือข่ายประสาทระดับสูงที่เขียนด้วยภาษา Python และสามารถทำงานบน TensorFlow, CNTK หรือ Theno เข้ากันได้กับ Python 2.7-3.6 คุณสามารถเรียนรู้เพิ่มเติมได้จากhttps://keras.io/.

ใช้คำสั่งต่อไปนี้เพื่อติดตั้ง keras -

pip install keras

บน conda คุณสามารถใช้คำสั่งต่อไปนี้ -

conda install –c conda-forge keras

การสร้าง Linear Regressor โดยใช้ ANN

ในส่วนนี้คุณจะได้เรียนรู้วิธีสร้างตัวถอยหลังเชิงเส้นโดยใช้โครงข่ายประสาทเทียม คุณสามารถใช้ได้KerasRegressorเพื่อให้บรรลุเป้าหมายนี้ ในตัวอย่างนี้เรากำลังใช้ชุดข้อมูลราคาบ้านของบอสตันที่มีตัวเลข 13 ตัวสำหรับคุณสมบัติในบอสตัน รหัส Python สำหรับสิ่งเดียวกันจะแสดงที่นี่ -

นำเข้าแพ็คเกจที่จำเป็นทั้งหมดตามที่แสดง -

import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold

ตอนนี้โหลดชุดข้อมูลของเราซึ่งบันทึกไว้ในไดเร็กทอรีท้องถิ่น

dataframe = pandas.read_csv("/Usrrs/admin/data.csv", delim_whitespace = True, header = None)
dataset = dataframe.values

ตอนนี้แบ่งข้อมูลออกเป็นตัวแปรอินพุตและเอาต์พุตเช่น X และ Y -

X = dataset[:,0:13]
Y = dataset[:,13]

เนื่องจากเราใช้โครงข่ายประสาทพื้นฐานกำหนดแบบจำลอง -

def baseline_model():

ตอนนี้สร้างแบบจำลองดังนี้ -

model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initializer = 'normal', 
   activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))

จากนั้นรวบรวมแบบจำลอง -

model_regressor.compile(loss='mean_squared_error', optimizer='adam')
return model_regressor

ตอนนี้แก้ไขเมล็ดพันธุ์แบบสุ่มสำหรับการทำซ้ำดังนี้ -

seed = 7
numpy.random.seed(seed)

วัตถุ Keras wrapper สำหรับใช้ใน scikit-learn เรียกว่าตัวประมาณค่าการถดถอย KerasRegressor. ในส่วนนี้เราจะประเมินโมเดลนี้ด้วยชุดข้อมูลที่เป็นมาตรฐาน

estimator = KerasRegressor(build_fn = baseline_model, nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_splits = 10, random_state = seed)
baseline_result = cross_val_score(estimator, X, Y, cv = kfold)
print("Baseline: %.2f (%.2f) MSE" % (Baseline_result.mean(),Baseline_result.std()))

ผลลัพธ์ของโค้ดที่แสดงด้านบนจะเป็นการประมาณประสิทธิภาพของโมเดลในปัญหาสำหรับข้อมูลที่มองไม่เห็น มันจะเป็นค่าความคลาดเคลื่อนกำลังสองเฉลี่ยรวมทั้งค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานในทั้ง 10 เท่าของการประเมินผลการตรวจสอบไขว้

Image Classifier: การประยุกต์ใช้ Deep Learning

Convolutional Neural Networks (CNNs) แก้ปัญหาการจัดประเภทรูปภาพนั่นคือคลาสที่อิมเมจอินพุตเป็นของ คุณสามารถใช้ Keras deep learning library โปรดทราบว่าเรากำลังใช้ชุดข้อมูลการฝึกและทดสอบภาพแมวและสุนัขจากลิงค์ต่อไปนี้https://www.kaggle.com/c/dogs-vs-cats/data.

นำเข้าไลบรารี Keras และแพ็คเกจที่สำคัญดังที่แสดง -

แพ็กเกจต่อไปนี้เรียกว่า sequential จะเริ่มต้นเครือข่ายประสาทเป็นเครือข่ายตามลำดับ

from keras.models import Sequential

แพคเกจต่อไปนี้เรียกว่า Conv2D ใช้ในการดำเนินการ Convolution ขั้นตอนแรกของ CNN

from keras.layers import Conv2D

แพคเกจต่อไปนี้เรียกว่า MaxPoling2D ใช้เพื่อดำเนินการร่วมกันซึ่งเป็นขั้นตอนที่สองของ CNN

from keras.layers import MaxPooling2D

แพคเกจต่อไปนี้เรียกว่า Flatten เป็นกระบวนการแปลงอาร์เรย์ 2 มิติที่เป็นผลลัพธ์ทั้งหมดให้เป็นเวกเตอร์เชิงเส้นที่ยาวต่อเนื่องกัน

from keras.layers import Flatten

แพคเกจต่อไปนี้เรียกว่า Dense ใช้เพื่อทำการเชื่อมต่อเครือข่ายประสาทเทียมขั้นตอนที่สี่ของ CNN

from keras.layers import Dense

ตอนนี้สร้างวัตถุของคลาสตามลำดับ

S_classifier = Sequential()

ตอนนี้ขั้นตอนต่อไปคือการเข้ารหัสส่วน Convolution

S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))

ที่นี่ relu คือฟังก์ชัน rectifier

ตอนนี้ขั้นตอนต่อไปของ CNN คือการดำเนินการร่วมกันบนแผนที่คุณลักษณะที่เป็นผลลัพธ์หลังจากส่วนการแปลง

S-classifier.add(MaxPooling2D(pool_size = (2, 2)))

ตอนนี้แปลงภาพรวมทั้งหมดเป็นเวกเตอร์ต่อเนื่องโดยใช้การยกยอ -

S_classifier.add(Flatten())

จากนั้นสร้างเลเยอร์ที่เชื่อมต่ออย่างสมบูรณ์

S_classifier.add(Dense(units = 128, activation = 'relu'))

นี่ 128 คือจำนวนหน่วยที่ซ่อนอยู่ เป็นเรื่องธรรมดาที่จะกำหนดจำนวนหน่วยที่ซ่อนอยู่เป็นพลังของ 2

ตอนนี้เริ่มต้นชั้นเอาต์พุตดังนี้ -

S_classifier.add(Dense(units = 1, activation = 'sigmoid'))

ตอนนี้รวบรวม CNN เราได้สร้าง -

S_classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

ที่นี่พารามิเตอร์เครื่องมือเพิ่มประสิทธิภาพคือการเลือกอัลกอริธึมการสืบเชื้อสายสุ่มแบบสุ่มพารามิเตอร์การสูญเสียคือการเลือกฟังก์ชันการสูญเสียและพารามิเตอร์เมตริกคือการเลือกเมตริกประสิทธิภาพ

ตอนนี้ทำการขยายภาพจากนั้นให้พอดีกับภาพกับโครงข่ายประสาทเทียม -

train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)

training_set = 
   train_datagen.flow_from_directory(”/Users/admin/training_set”,target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

test_set = 
   test_datagen.flow_from_directory('test_set',target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

ตอนนี้ปรับข้อมูลให้พอดีกับแบบจำลองที่เราสร้างขึ้น -

classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs = 
25,validation_data = test_set,validation_steps = 2000)

ที่นี่ steps_per_epoch มีจำนวนภาพการฝึกอบรม

ขณะนี้โมเดลได้รับการฝึกฝนแล้วเราสามารถใช้เพื่อทำนายได้ดังนี้ -

from keras.preprocessing import image

test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg', 
target_size = (64, 64))

test_image = image.img_to_array(test_image)

test_image = np.expand_dims(test_image, axis = 0)

result = classifier.predict(test_image)

training_set.class_indices

if result[0][0] == 1:
prediction = 'dog'

else:
   prediction = 'cat'