Keras กวดวิชา

เคราสคืออะไร?

Keras เป็นไลบรารี Open Source Neural Network ที่เขียนขึ้น Python ที่ทำงานบน Theano หรือ Tensorflow ได้รับการออกแบบให้เป็นโมดูลาร์ รวดเร็ว และใช้งานง่าย ได้รับการพัฒนาโดย François Chollet วิศวกรของ Google Keras ไม่รองรับการคำนวณระดับต่ำ แต่จะใช้ไลบรารีอื่นแทน เรียกว่า "แบ็กเอนด์"

Keras คือ Wrapper API ระดับสูงสำหรับ API ระดับต่ำ ซึ่งสามารถทำงานบน TensorFlow, CNTK หรือ Theano ได้ Keras High-Level API จัดการวิธีที่เราสร้างโมเดล กำหนดเลเยอร์ หรือตั้งค่าโมเดลอินพุต-เอาต์พุตหลายรายการ ในระดับนี้ Keras ยังรวบรวมโมเดลของเราด้วยฟังก์ชันการสูญเสียและเครื่องมือเพิ่มประสิทธิภาพ กระบวนการฝึกอบรมพร้อมฟังก์ชันพอดี เคราเข้าแล้ว Python ไม่รองรับ Low-Level API เช่น การสร้างกราฟการคำนวณ การสร้างเทนเซอร์ หรือตัวแปรอื่นๆ เนื่องจากได้รับการจัดการโดยกลไก "แบ็กเอนด์"

แบ็กเอนด์คืออะไร?

แบ็กเอนด์เป็นคำศัพท์ใน Keras ที่ใช้คำนวณระดับต่ำทั้งหมด เช่น ผลิตภัณฑ์เทนเซอร์ การโน้มน้าวใจ และอื่นๆ อีกมากมายด้วยความช่วยเหลือของไลบรารีอื่นๆ เช่น Tensorflow หรือ Theano ดังนั้น “เอ็นจิ้นแบ็กเอนด์” จะทำการคำนวณและพัฒนาโมเดล Tensorflow เป็น "เอ็นจิ้นแบ็กเอนด์" เริ่มต้น แต่เราสามารถเปลี่ยนได้ในการกำหนดค่า

Theano, Tensorflow และแบ็กเอนด์ CNTK

Theano เป็นโครงการโอเพ่นซอร์สที่พัฒนาโดยกลุ่ม MILA ที่มหาวิทยาลัยมอนทรีออล ควิเบก ประเทศแคนาดา เป็น Framework แรกที่ใช้กันอย่างแพร่หลาย มันคือก Python ไลบรารีที่ช่วยในอาร์เรย์หลายมิติสำหรับการดำเนินการทางคณิตศาสตร์โดยใช้ Numpy หรือ Scipy Theano สามารถใช้ GPU เพื่อการคำนวณที่เร็วขึ้น นอกจากนี้ยังสามารถสร้างกราฟเชิงสัญลักษณ์สำหรับการคำนวณการไล่ระดับได้โดยอัตโนมัติ บนเว็บไซต์ Theano อ้างว่าสามารถจดจำนิพจน์ที่ไม่เสถียรในเชิงตัวเลขและคำนวณด้วยอัลกอริทึมที่เสถียรกว่า ซึ่งมีประโยชน์มากสำหรับนิพจน์ที่ไม่เสถียรของเรา

ในทางกลับกัน Tensorflow ถือเป็นดาวเด่นในกรอบการเรียนรู้เชิงลึก พัฒนาโดยทีม Brain ของ Google เป็นเครื่องมือการเรียนรู้เชิงลึกที่ได้รับความนิยมมากที่สุด ด้วยคุณสมบัติมากมายและนักวิจัยมีส่วนช่วยพัฒนากรอบการทำงานนี้เพื่อวัตถุประสงค์ในการเรียนรู้เชิงลึก

เอ็นจิ้นแบ็กเอนด์อีกตัวสำหรับ Keras คือ The Microsoft ชุดเครื่องมือความรู้ความเข้าใจหรือ CNTK เป็นกรอบการเรียนรู้เชิงลึกแบบโอเพ่นซอร์สที่พัฒนาโดย Microsoft ทีม. สามารถทำงานบน GPU หลายตัวหรือหลายเครื่องเพื่อฝึกฝนโมเดลการเรียนรู้เชิงลึกในวงกว้าง ในบางกรณี CNTK ได้รับการรายงานเร็วกว่าเฟรมเวิร์กอื่นๆ เช่น Tensorflow หรือ Theano ต่อไปในบทช่วยสอน Keras CNN นี้ เราจะเปรียบเทียบแบ็กเอนด์ของ Theano, TensorFlow และ CNTK

การเปรียบเทียบแบ็กเอนด์

เราจำเป็นต้องทำการวัดประสิทธิภาพเพื่อที่จะทราบการเปรียบเทียบระหว่างแบ็กเอนด์ทั้งสองนี้ อย่างที่คุณเห็นใน เกณฑ์มาตรฐานของจองยุนลีจะมีการเปรียบเทียบประสิทธิภาพของแบ็กเอนด์ที่แตกต่างกัน 3 รายการบนฮาร์ดแวร์ที่แตกต่างกัน และผลลัพธ์ก็คือ Theano ช้ากว่าแบ็กเอนด์อื่น ๆ มีรายงาน ครั้ง 50 ช้ากว่าแต่ความแม่นยำใกล้เคียงกัน

อื่น การทดสอบมาตรฐาน ดำเนินการโดย จัสมีต บาเทีย- เขารายงานว่า Theano ช้ากว่า Tensorflow สำหรับการทดสอบบางอย่าง แต่ความแม่นยำโดยรวมเกือบจะเหมือนกันสำหรับทุกเครือข่ายที่ทดสอบ

ดังนั้น ระหว่าง Theano, Tensorflow และ CTK เห็นได้ชัดว่า TensorFlow ดีกว่า Theano ด้วย TensorFlow เวลาในการคำนวณจะสั้นลงมาก และ CNN ก็ดีกว่าอื่นๆ

ต่อไปใน Keras นี้ Python บทช่วยสอน เราจะเรียนรู้เกี่ยวกับความแตกต่างระหว่าง Keras และ TensorFlow (Keras กับ Tensorflow).

Keras กับ Tensorflow

พารามิเตอร์	Keras	เทนเซอร์โฟลว์
ประเภท	Wrapper API ระดับสูง	API ระดับต่ำ
ความซับซ้อน	ใช้งานง่ายถ้าคุณ Python language	คุณต้องเรียนรู้ไวยากรณ์ของการใช้ฟังก์ชัน Tensorflow บางส่วน
จุดมุ่งหมาย	การปรับใช้อย่างรวดเร็วสำหรับการสร้างโมเดลด้วยเลเยอร์มาตรฐาน	ช่วยให้คุณสร้างกราฟการคำนวณหรือเลเยอร์โมเดลได้ตามใจชอบ
เครื่องมือ	ใช้เครื่องมือแก้ไขข้อบกพร่อง API อื่น ๆ เช่น TFDBG	คุณสามารถใช้เครื่องมือแสดงภาพ Tensorboard ได้
สังคม	ชุมชนขนาดใหญ่ที่มีการเคลื่อนไหว	ชุมชนขนาดใหญ่ที่กระตือรือร้นและทรัพยากรที่ใช้ร่วมกันอย่างกว้างขวาง

ข้อดีของ Keras

การปรับใช้ที่รวดเร็วและเข้าใจง่าย

Keras รวดเร็วมากในการสร้างโมเดลเครือข่าย หากคุณต้องการสร้างโมเดลเครือข่ายง่ายๆ เพียงไม่กี่บรรทัด Python Keras สามารถช่วยคุณได้ ดูตัวอย่าง Keras ด้านล่าง:

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential()
model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50
model.add(Dense(28, activation='relu')) #input shape of 50
model.add(Dense(10, activation='softmax'))

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

การสนับสนุนชุมชนขนาดใหญ่

มีชุมชน AI จำนวนมากที่ใช้ Keras สำหรับเฟรมเวิร์ก Deep Learning หลายคนเผยแพร่รหัสของตนรวมถึงบทช่วยสอนให้กับประชาชนทั่วไป

มีแบ็กเอนด์หลายรายการ

คุณสามารถเลือก Tensorflow, CNTK และ Theano เป็นแบ็กเอนด์ของคุณด้วย Keras คุณสามารถเลือกแบ็กเอนด์ที่แตกต่างกันสำหรับโปรเจ็กต์ต่างๆ ได้ตามความต้องการของคุณ แต่ละแบ็กเอนด์มีข้อได้เปรียบที่เป็นเอกลักษณ์ของตัวเอง

ข้ามแพลตฟอร์มและการปรับใช้โมเดลอย่างง่าย

ด้วยอุปกรณ์และแพลตฟอร์มที่รองรับที่หลากหลาย คุณสามารถปรับใช้ Keras บนอุปกรณ์ใดก็ได้

• iOS พร้อม CoreML
• Android ด้วยเทนเซอร์โฟลว์ Android,
• เว็บเบราว์เซอร์ที่รองรับ .js
• เครื่องยนต์คลาวด์
• ราสเบอร์รี่ Pi

รองรับ GPU หลายตัว

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

ข้อเสียของ Keras

ไม่สามารถจัดการ API ระดับต่ำได้

Keras จัดการเฉพาะ API ระดับสูงที่ทำงานบนเฟรมเวิร์กหรือกลไกแบ็กเอนด์อื่น ๆ เช่น Tensorflow, Theano หรือ CNTK ดังนั้นจึงไม่มีประโยชน์มากนักหากคุณต้องการสร้างเลเยอร์นามธรรมของคุณเองเพื่อการวิจัย เนื่องจาก Keras มีเลเยอร์ที่กำหนดค่าไว้ล่วงหน้าแล้ว

การติดตั้ง Keras

ในส่วนนี้ เราจะดูวิธีการต่างๆ สำหรับการติดตั้ง Keras

ติดตั้งโดยตรงหรือสภาพแวดล้อมเสมือน

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

เช่นฉันมีโครงการที่ต้องการ Python 3.5 โดยใช้ OpenCV 3.3 กับแบ็กเอนด์ Keras-Theano รุ่นเก่า แต่ในโปรเจ็กต์อื่นฉันต้องใช้ Keras กับเวอร์ชันล่าสุดและ Tensorflow เนื่องจากแบ็กเอนด์ด้วย Python รองรับ 3.6.6

เราไม่ต้องการให้ไลบรารี Keras ขัดแย้งกันใช่ไหม ดังนั้นเราจึงใช้ Virtual Environment เพื่อแปลโปรเจ็กต์ด้วยไลบรารีประเภทเฉพาะหรือเราจะใช้แพลตฟอร์มอื่นเช่น Cloud Service เพื่อทำการคำนวณให้เราเช่น Amazon บริการเว็บ.

กำลังติดตั้ง Keras บน Amazon บริการเว็บ (AWS)

Amazon Web Service เป็นแพลตฟอร์มที่ให้บริการและผลิตภัณฑ์ Cloud Computing สำหรับนักวิจัยหรือวัตถุประสงค์อื่นใด AWS เช่าฮาร์ดแวร์ เครือข่าย ฐานข้อมูล ฯลฯ เพื่อให้เราสามารถใช้งานได้โดยตรงจากอินเทอร์เน็ต หนึ่งในบริการ AWS ยอดนิยมสำหรับการเรียนรู้เชิงลึกคือ Amazon บริการการเรียนรู้เชิงลึกของอิมเมจเครื่องหรือ DL

สำหรับคำแนะนำโดยละเอียดเกี่ยวกับวิธีใช้ AWS โปรดดูที่นี้ เกี่ยวกับการสอน

หมายเหตุเกี่ยวกับ AMI: คุณจะมี AMI ต่อไปนี้

AWS Deep Learning AMI คือสภาพแวดล้อมเสมือนจริงในบริการ AWS EC2 ที่ช่วยให้นักวิจัยหรือผู้ปฏิบัติงานทำงานกับ Deep Learning ได้ DLAMI นำเสนอตั้งแต่กลไก CPU ขนาดเล็กไปจนถึงกลไก GPU หลายตัวกำลังสูงพร้อม CUDA, cuDNN ที่กำหนดค่าไว้ล่วงหน้า และมาพร้อมกับเฟรมเวิร์กการเรียนรู้เชิงลึกที่หลากหลาย

หากคุณต้องการใช้งานทันที คุณควรเลือก Deep Learning AMI เนื่องจากมีการติดตั้งเฟรมเวิร์ก Deep Learning ยอดนิยมไว้ล่วงหน้า

แต่หากคุณต้องการลองใช้เฟรมเวิร์กการเรียนรู้เชิงลึกแบบกำหนดเองสำหรับการวิจัย คุณควรติดตั้ง Deep Learning Base AMI เนื่องจากมาพร้อมกับไลบรารีพื้นฐาน เช่น CUDA, cuDNN, ไดรเวอร์ GPU และไลบรารีที่จำเป็นอื่นๆ เพื่อรันกับสภาพแวดล้อมการเรียนรู้เชิงลึกของคุณ

วิธีการติดตั้ง Keras บน Amazon SageMaker

Amazon SageMaker เป็นแพลตฟอร์มการเรียนรู้เชิงลึกที่จะช่วยคุณในการฝึกอบรมและปรับใช้เครือข่ายการเรียนรู้เชิงลึกด้วยอัลกอริทึมที่ดีที่สุด

ในฐานะมือใหม่ นี่เป็นวิธีที่ง่ายที่สุดในการใช้ Keras ด้านล่างนี้เป็นกระบวนการเกี่ยวกับวิธีการติดตั้ง Keras Amazon SageMaker:

ขั้นตอนที่ 1) เปิด Amazon SageMaker

ในขั้นตอนแรก ให้เปิดไฟล์ Amazon ปราชญ์ console แล้วคลิกสร้างอินสแตนซ์สมุดบันทึก

ขั้นตอนที่ 2) กรอกรายละเอียด

1. ป้อนชื่อสมุดบันทึกของคุณ
2. สร้างบทบาท IAM มันจะสร้างบทบาท AMI Amazon บทบาท IAM ในรูปแบบของ AmazonSageMaker-บทบาทการดำเนินการ-ปปปปดดด|ฮึ่มSS
3. สุดท้าย เลือกสร้างอินสแตนซ์สมุดบันทึก หลังจากนั้นครู่หนึ่ง Amazon Sagemaker เปิดตัวอินสแตนซ์โน้ตบุ๊ก

หมายเหตุ:หากคุณต้องการเข้าถึงทรัพยากรจาก VPC ของคุณ ให้ตั้งค่าการเข้าถึงอินเทอร์เน็ตโดยตรงเป็นเปิดใช้งาน มิฉะนั้น อินสแตนซ์โน้ตบุ๊กนี้จะไม่มีการเข้าถึงอินเทอร์เน็ต ดังนั้นจึงไม่สามารถฝึกหรือโฮสต์โมเดลได้

ขั้นตอนที่ 3) เปิดใช้งานอินสแตนซ์

คลิกที่เปิดเพื่อเปิดอินสแตนซ์

ขั้นตอนที่ 4) เริ่มการเข้ารหัส

In Jupyterคลิกที่ใหม่> conda_tensorflow_p36 และคุณพร้อมที่จะเขียนโค้ดแล้ว

ติดตั้ง Keras ใน Linux

หากต้องการเปิดใช้งาน Keras ด้วย Tensorflow เป็นเครื่องมือแบ็กเอนด์ เราจำเป็นต้องติดตั้ง Tensorflow ก่อน รันคำสั่งนี้เพื่อติดตั้ง tensorflow ด้วย CPU (ไม่มี GPU)

pip install --upgrade tensorflow

หากคุณต้องการเปิดใช้งานการรองรับ GPU สำหรับเทนเซอร์โฟลว์ คุณสามารถใช้คำสั่งนี้

pip install --upgrade tensorflow-gpu

มาเช็คอินกันดีกว่า Python เพื่อดูว่าการติดตั้งของเราสำเร็จโดยการพิมพ์หรือไม่

user@user:~$ python
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow
>>>

หากไม่มีข้อความแสดงข้อผิดพลาด แสดงว่ากระบวนการติดตั้งสำเร็จ

ติดตั้ง Keras

หลังจากที่เราติดตั้ง Tensorflow มาเริ่มติดตั้ง keras กัน พิมพ์คำสั่งนี้ในเทอร์มินัล

pip install keras

มันจะเริ่มการติดตั้ง Keras และการขึ้นต่อกันทั้งหมด คุณควรเห็นสิ่งนี้:

ตอนนี้เราได้ติดตั้ง Keras ในระบบของเราแล้ว!

การตรวจสอบ

ก่อนที่เราจะเริ่มใช้ Keras เราควรตรวจสอบว่า Keras ของเราใช้ Tensorflow เป็นแบ็กเอนด์หรือไม่โดยเปิดไฟล์การกำหนดค่า:

gedit ~/.keras/keras.json

คุณควรเห็นอะไรแบบนี้

{
    "floatx": "float32",
    "epsilon": 1e-07,
    "backend": "tensorflow",
    "image_data_format": "channels_last"
}

อย่างที่คุณเห็น “แบ็กเอนด์” ใช้เทนเซอร์โฟลว์ หมายความว่า keras กำลังใช้ Tensorflow เป็นแบ็กเอนด์ตามที่เราคาดไว้

และตอนนี้รันบนเทอร์มินัลโดยพิมพ์

user@user:~$ python3
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import keras
Using TensorFlow backend.
>>> 

วิธีการติดตั้ง Keras บน Windows

ก่อนที่เราจะติดตั้ง เทนเซอร์โฟลว์ และ Keras เราควรติดตั้ง Python, pip และ virtualenv หากคุณได้ติดตั้งไลบรารีเหล่านี้แล้ว คุณควรดำเนินการตามขั้นตอนถัดไป มิฉะนั้น ให้ดำเนินการดังต่อไปนี้:

การติดตั้ง Python 3 โดยการดาวน์โหลดจากนี้ ลิงค์

ติดตั้ง pip ด้วยการรัน นี้

ติดตั้ง virtualenv ด้วยคำสั่งนี้

pip3 install –U pip virtualenv

การติดตั้ง Microsoft ของ Visual C++ 2015 อัปเดตที่สามารถเผยแพร่ต่อได้ 3

• ไปที่เว็บไซต์ดาวน์โหลด Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
• เลือกการแจกจ่ายต่อและสร้างเครื่องมือ
• ดาวน์โหลดและติดตั้ง Microsoft ของ Visual C++ 2015 อัปเดตที่สามารถเผยแพร่ต่อได้ 3

จากนั้นรันสคริปต์นี้

pip3 install virtualenv

ตั้งค่าสภาพแวดล้อมเสมือน

ใช้เพื่อแยกระบบการทำงานออกจากระบบหลัก

virtualenv –-system-site-packages –p python3 ./venv

เปิดใช้งานสภาพแวดล้อม

.\venv\Scripts\activate

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

ความรู้พื้นฐาน Keras สำหรับการเรียนรู้เชิงลึก

โครงสร้างหลักใน Keras คือ Model ซึ่งกำหนดกราฟที่สมบูรณ์ของเครือข่าย คุณสามารถเพิ่มเลเยอร์ให้กับโมเดลที่มีอยู่เพื่อสร้างโมเดลแบบกำหนดเองที่คุณต้องการสำหรับโปรเจ็กต์ของคุณ

ต่อไปนี้คือวิธีสร้าง Sequential Model และเลเยอร์บางส่วนที่ใช้กันทั่วไปในการเรียนรู้เชิงลึก

1. แบบจำลองตามลำดับ

from keras.models import Sequential
from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout

model = Sequential()

2. ชั้น Convolutional

นี่คือเครา Python ตัวอย่างของเลเยอร์ Convolutional เป็นเลเยอร์อินพุตที่มีรูปร่างอินพุต 320x320x3 โดยมีฟิลเตอร์ขนาด 48×3 จำนวน 3 ตัว และใช้ ReLU เป็นฟังก์ชันการเปิดใช้งาน

input_shape=(320,320,3) #this is the input shape of an image 320x320x3
model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))

อีกประเภทหนึ่งคือ

model.add(Conv2D(48, (3, 3), activation='relu'))

3. สูงสุดPoolinก. เลเยอร์

หากต้องการลดตัวอย่างการแสดงอินพุต ให้ใช้ MaxPool2d และระบุขนาดเคอร์เนล

model.add(MaxPooling2D(pool_size=(2, 2)))

4. ชั้นหนาแน่น

เพิ่มเลเยอร์ที่เชื่อมต่ออย่างสมบูรณ์โดยเพียงระบุขนาดเอาต์พุต

model.add(Dense(256, activation='relu'))

5. เลเยอร์ออกกลางคัน

การเพิ่มเลเยอร์การออกกลางคันด้วยความน่าจะเป็น 50%

model.add(Dropout(0.5))

การรวบรวม การฝึกอบรม และการประเมินผล

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

model.compile(loss='mean_squared_error', optimizer='adam')

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

model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

ขั้นตอนสุดท้ายของเราคือการประเมินโมเดลด้วยข้อมูลการทดสอบ

score = model.evaluate(x_test, y_test, batch_size=32)

ลองใช้การถดถอยเชิงเส้นอย่างง่าย

import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt 
 
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3


model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))

model.compile(optimizer='sgd', loss='mse', metrics=['mse'])

weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init)) 


model.fit(x,y, batch_size=1, epochs=30, shuffle=False)

weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))

predict = model.predict(data)

plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()

หลังจากฝึกฝนข้อมูลแล้ว ผลลัพธ์ควรมีลักษณะเช่นนี้

ด้วยน้ำหนักเริ่มต้น

Linear regression model is initialized with weights w: 0.37, b: 0.00

และน้ำหนักสุดท้าย

Linear regression model is trained to have weight w: 3.70, b: 0.61

ปรับแต่งโมเดลที่ได้รับการฝึกอบรมล่วงหน้าใน Keras และวิธีการใช้งาน

เหตุใดเราจึงใช้ Fine Tune Models และเมื่อเราใช้งาน

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

ตัวอย่างเช่น หากเราต้องการฝึกโมเดล Keras ของเราเองเพื่อแก้ไขปัญหาการจำแนกประเภทแต่เรามีข้อมูลเพียงเล็กน้อย เราก็สามารถแก้ไขได้โดยใช้ ถ่ายทอดการเรียนรู้ + วิธีการปรับแต่งแบบละเอียด

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

การเตรียมโมเดลเครือข่าย

สำหรับโมเดลก่อนการฝึก เราสามารถโหลดโมเดลต่างๆ ที่ Keras มีอยู่แล้วในไลบรารีได้ เช่น:

• วีจีจี16
• อินเซ็ปชั่นV3
• เรสเน็ต
• โมบายเน็ต
• เอ็กซ์เซ็ปชั่น
• InceptionResNetV2

แต่ในกระบวนการนี้ เราจะใช้โมเดลเครือข่าย VGG16 และ imageNet เป็นน้ำหนักของเราสำหรับโมเดล เราจะปรับแต่งเครือข่ายเพื่อจำแนกคลาสที่แตกต่างกัน 8 ประเภทโดยใช้รูปภาพจาก ชุดข้อมูลรูปภาพธรรมชาติ Kaggle

สถาปัตยกรรมโมเดล VGG16

แหล่ง

การอัปโหลดข้อมูลของเราไปยัง AWS S3 Bucket

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

Amazon ถัง S3

ขั้นตอน 1) หลังจากเข้าสู่ระบบบัญชี S3 ของคุณแล้ว มาสร้างบัคเก็ตด้วยการตอกบัตรกัน สร้างถัง

ขั้นตอน 2) ตอนนี้เลือกชื่อบัคเก็ตและภูมิภาคของคุณตามบัญชีของคุณ ตรวจสอบให้แน่ใจว่าชื่อที่เก็บข้อมูลพร้อมใช้งาน หลังจากนั้นให้คลิก สร้าง

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

ขั้นตอน 4) ตอนนี้คุณเริ่มอัปโหลดข้อมูลการฝึกอบรมไปยัง Bucket ของคุณแล้ว ที่นี่ฉันจะอัปโหลดไฟล์ tar.gz ซึ่งประกอบด้วยรูปภาพสำหรับการฝึกอบรมและกระบวนการทดสอบ

ขั้นตอน 5) ตอนนี้คลิกที่ไฟล์ของคุณแล้วคัดลอกไฟล์ ลิงค์ เพื่อให้เราสามารถดาวน์โหลดได้

การเตรียมข้อมูล

เราจำเป็นต้องสร้างข้อมูลการฝึกอบรมของเราโดยใช้ Keras ImageDataGenerator.

ขั้นแรก คุณต้องดาวน์โหลดโดยใช้ wget พร้อมลิงก์ไปยังไฟล์ของคุณจาก S3 Bucket

!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz		
!tar -xzf images.tar.gz

หลังจากที่คุณดาวน์โหลดข้อมูลแล้ว มาเริ่มกระบวนการฝึกอบรมกันดีกว่า

from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt

train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8


train_datagen = ImageDataGenerator(validation_split=0.3,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

ImageDataGenerator จะสร้างข้อมูล X_training จากไดเร็กทอรี ไดเร็กทอรีย่อยในไดเร็กทอรีนั้นจะถูกใช้เป็นคลาสสำหรับแต่ละออบเจ็กต์ รูปภาพจะถูกโหลดด้วยโหมดสี RGB พร้อมด้วยโหมดคลาสหมวดหมู่สำหรับข้อมูล Y_training โดยมีขนาดแบทช์เท่ากับ 16 สุดท้าย ให้สับเปลี่ยนข้อมูล

มาดูภาพของเราแบบสุ่มโดยพล็อตพวกมันด้วย matplotlib

x_batch, y_batch = train_generator.next()

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
    num = np.random.randint(batch_size)
    image = x_batch[num].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.imshow(image)
plt.show()

หลังจากนั้น เรามาสร้างโมเดลเครือข่ายของเราจาก VGG16 ด้วยตุ้มน้ำหนักที่ฝึกล่วงหน้าของ imageNet เราจะหยุดเลเยอร์เหล่านี้เพื่อไม่ให้เลเยอร์เหล่านี้สามารถฝึกได้ เพื่อช่วยลดเวลาในการคำนวณ

การสร้างโมเดลของเราจาก VGG16

import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16


#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))

print(base_model.summary())

    # Freeze the layers 
for layer in base_model.layers:
    layer.trainable = False
 
# # Create the model
model = keras.models.Sequential()

# # Add the vgg convolutional base model
model.add(base_model)
 
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
 
# # Show a summary of the model. Check the number of trainable parameters    
print(model.summary())

ดังที่คุณเห็นด้านล่าง สรุปโมเดลเครือข่ายของเรา จากอินพุตจากเลเยอร์ VGG16 เราจะเพิ่มเลเยอร์ที่เชื่อมต่ออย่างสมบูรณ์ 2 เลเยอร์ซึ่งจะแยกคุณสมบัติ 1024 รายการและเลเยอร์เอาท์พุตที่จะคำนวณ 8 คลาสด้วยการเปิดใช้งาน softmax

Layer (type)                 Output Shape              Param #   
=================================================================
vgg16 (Model)                (None, 7, 7, 512)         14714688  
_________________________________________________________________
flatten_1 (Flatten)          (None, 25088)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              25691136  
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 8)                 8200      
=================================================================
Total params: 41,463,624
Trainable params: 26,748,936
Non-trainable params: 14,714,688

องค์กร

# # Compile the model
from keras.optimizers import SGD

model.compile(loss='categorical_crossentropy',
          optimizer=SGD(lr=1e-3),
          metrics=['accuracy'])

# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)

# # #save the model
# model.save('catdog.h5')

history = model.fit_generator(
        train_generator,
        steps_per_epoch=train_generator.n/batch_size,
        epochs=10)
        
model.save('fine_tune.h5')

# summarize history for accuracy
import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()

ผลสอบ

Epoch 1/10
432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 
Epoch 2/10
432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831
Epoch 3/10
432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871
Epoch 4/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926
Epoch 5/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938
Epoch 6/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936
Epoch 7/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958
Epoch 8/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959
Epoch 9/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942
Epoch 10/10
432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947

อย่างที่คุณเห็น การสูญเสียของเราลดลงอย่างมากและมีความแม่นยำเกือบ 100% สำหรับการทดสอบโมเดลของเรา เราได้สุ่มเลือกรูปภาพทางอินเทอร์เน็ตและนำไปไว้ในโฟลเดอร์ทดสอบที่มีคลาสอื่นเพื่อทดสอบ

ทดสอบโมเดลของเรา

model = load_model('fine_tune.h5')

test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

test_generator = test_datagen.flow_from_directory(
                        directory=test_path, 
                        target_size=(image_size, image_size),
                        color_mode='rgb',
                        shuffle=False,
                        class_mode='categorical',
                        batch_size=1)

filenames = test_generator.filenames
nb_samples = len(filenames)

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
    x_batch, y_batch = test_generator.next()

    name = model.predict(x_batch)
    name = np.argmax(name, axis=-1)
    true_name = y_batch
    true_name = np.argmax(true_name, axis=-1)

    label_map = (test_generator.class_indices)
    label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
    predictions = [label_map[k] for k in name]
    true_value = [label_map[k] for k in true_name]

    image = x_batch[0].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.title(str(predictions[0]) + ':' + str(true_value[0]))
    plt.imshow(image)
plt.show()

และการทดสอบของเราเป็นไปตามที่ระบุด้านล่าง! ทำนายผิดเพียง 1 ภาพจากการทดสอบ 14 ภาพ!

โครงข่ายประสาทเทียมการจดจำใบหน้าด้วย Keras

ทำไมเราต้องได้รับการยอมรับ

เราจำเป็นต้องมีการจดจำเพื่อให้ง่ายขึ้นสำหรับเราในการจดจำหรือระบุใบหน้าของบุคคล ประเภทวัตถุ อายุโดยประมาณของบุคคลจากใบหน้าของเขา หรือแม้แต่ทราบการแสดงออกทางสีหน้าของบุคคลนั้น

บางทีคุณอาจตระหนักได้ว่าทุกครั้งที่คุณพยายามทำเครื่องหมายใบหน้าเพื่อนของคุณในรูปถ่าย ฟีเจอร์ใน Facebook ช่วยคุณได้ นั่นคือการทำเครื่องหมายใบหน้าเพื่อนของคุณโดยที่คุณไม่จำเป็นต้องทำเครื่องหมายก่อน นี่คือ Face Recognition ที่ใช้โดย Facebook เพื่อให้เราแท็กเพื่อนได้ง่ายขึ้น

แล้วมันทำงานยังไง? ทุกครั้งที่เรามาร์กหน้าเพื่อน AI ของ Facebook จะเรียนรู้และจะพยายามคาดเดาจนกว่าจะได้ผลลัพธ์ที่ถูกต้อง ระบบเดียวกับที่เราจะใช้สร้าง Face Recognition ของเราเอง มาเริ่มสร้าง Face Recognition ของเราเองโดยใช้ Deep Learning กันดีกว่า

โมเดลเครือข่าย

เราจะใช้โมเดลเครือข่าย VGG16 แต่มีน้ำหนัก VGGFace

สถาปัตยกรรมโมเดล VGG16

VGGFace คืออะไร? เป็นการนำ Deep Face Recognition ของ Keras มาใช้ ซึ่งแนะนำโดย Parkhi, Omkar M. และคณะ “Deep Face Recognition” โดย BMVC (2015) เฟรมเวิร์กนี้ใช้ VGG16 เป็นสถาปัตยกรรมเครือข่าย

คุณสามารถดาวน์โหลด VGGFace ได้จาก GitHub

from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace

face_model = VGGFace(model='vgg16', 
                weights='vggface',
                input_shape=(224,224,3)) 
face_model.summary()

ดังที่คุณเห็นสรุปเครือข่าย

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0         
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792      
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928     
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0         
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856     
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584    
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0         
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168    
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0         
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160   
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0         
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0         
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0         
_________________________________________________________________
fc6 (Dense)                  (None, 4096)              102764544 
_________________________________________________________________
fc6/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc7 (Dense)                  (None, 4096)              16781312  
_________________________________________________________________
fc7/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc8 (Dense)                  (None, 2622)              10742334  
_________________________________________________________________
fc8/softmax (Activation)     (None, 2622)              0         
=================================================================
Total params: 145,002,878
Trainable params: 145,002,878
Non-trainable params: 0
_________________________________________________________________
Traceback (most recent call last):

เราจะทำ ถ่ายทอดการเรียนรู้ + การปรับแต่งอย่างละเอียดเพื่อให้การฝึกอบรมเร็วขึ้นด้วยชุดข้อมูลขนาดเล็ก ขั้นแรก เราจะตรึงชั้นฐานเพื่อไม่ให้ชั้นต่างๆ ไม่สามารถฝึกได้

for layer in face_model.layers:
    layer.trainable = False

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

from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation

person_count = 5

last_layer = face_model.get_layer('pool5').output

x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)

custom_face = Model(face_model.input, out)

มาดูสรุปเครือข่ายของเรากัน

Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0
_________________________________________________________________
fc6 (Dense)                  (None, 1024)              25691136
_________________________________________________________________
fc7 (Dense)                  (None, 1024)              1049600
_________________________________________________________________
fc8 (Dense)                  (None, 5)                 5125
=================================================================
Total params: 41,460,549
Trainable params: 26,745,861
Non-trainable params: 14,714,688

ดังที่คุณเห็นด้านบน หลังจากเลเยอร์ pool5 แล้ว มันจะถูกทำให้แบนเป็นเวกเตอร์คุณลักษณะเดียวที่จะถูกใช้โดยเลเยอร์หนาแน่นสำหรับการจดจำขั้นสุดท้าย

การเตรียมใบหน้าของเรา

ตอนนี้เรามาเตรียมใบหน้าของเรากันดีกว่า ฉันจัดทำไดเร็กทอรีประกอบด้วยบุคคลที่มีชื่อเสียง 5 คน

• แจ็คหม่า
• Statham เจสัน
• Johnny Depp
• โรเบิร์ตดาวนี่ย์จูเนียร์
• แอตกินสันโร

แต่ละโฟลเดอร์ประกอบด้วย 10 รูปภาพ สำหรับแต่ละกระบวนการฝึกอบรมและประเมินผล มันเป็นข้อมูลจำนวนน้อยมาก แต่นั่นคือความท้าทายใช่ไหม

เราจะใช้ความช่วยเหลือของเครื่องมือ Keras เพื่อช่วยเราเตรียมข้อมูล ฟังก์ชันนี้จะวนซ้ำในโฟลเดอร์ชุดข้อมูล จากนั้นจัดเตรียมเพื่อให้สามารถใช้ในการฝึกอบรมได้

from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'

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

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

train_generator = train_datagen.flow_from_directory(
                        train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='sparse',
                        color_mode='rgb')

valid_generator = valid_datagen.flow_from_directory(
    directory=eval_path,
    target_size=(224, 224),
    color_mode='rgb',
    batch_size=batch_size,
    class_mode='sparse',
    shuffle=True,
)

ฝึกอบรมโมเดลของเรา

มาเริ่มกระบวนการฝึกอบรมของเราโดยรวบรวมเครือข่ายของเราด้วยฟังก์ชันการสูญเสียและเครื่องมือเพิ่มประสิทธิภาพ ที่นี่ เราใช้ sparse_categorical_crossentropy เป็นฟังก์ชันการสูญเสียของเรา โดยมี SGD เป็นตัวเพิ่มประสิทธิภาพการเรียนรู้ของเรา

from keras.optimizers import SGD

custom_face.compile(loss='sparse_categorical_crossentropy',
                         optimizer=SGD(lr=1e-4, momentum=0.9),
                         metrics=['accuracy'])

history = custom_face.fit_generator(
        train_generator,
        validation_data=valid_generator,
        steps_per_epoch=49/batch_size,
        validation_steps=valid_generator.n,
        epochs=50)

custom_face.evaluate_generator(generator=valid_generator)
        
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266

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

มาทดสอบโมเดลของเราด้วยภาพทดสอบกัน

from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input

test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)

labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']

โดยใช้รูปภาพของ Robert Downey Jr. เป็นภาพทดสอบ พบว่าใบหน้าที่ทำนายไว้นั้นเป็นเรื่องจริง!

ทำนายผลโดยใช้ Live Cam!

แล้วถ้าเราทดสอบทักษะของเราด้วยการปรับใช้มันด้วยอินพุตจากเว็บแคมล่ะ? การใช้ OpenCV กับ Haar Face cascade เพื่อค้นหาใบหน้าของเรา และด้วยความช่วยเหลือของโมเดลเครือข่ายของเรา เราก็สามารถจดจำบุคคลนั้นได้

ขั้นตอนแรกคือเตรียมใบหน้าของคุณและเพื่อนของคุณให้พร้อม ยิ่งเรามีข้อมูลมากเท่าไร ผลลัพธ์ก็จะยิ่งดีขึ้นเท่านั้น!

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

#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2

image_size = 224
device_id = 0 #camera_device id 

model = load_model('my faces.h5')

#make labels according to your dataset folder 
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)

cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)

while camera.isOpened():
    ok, cam_frame = camera.read()
    if not ok:
        break
    
    gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
    faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)

    for (x,y,w,h) in faces:
        cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
        roi_color = cam_frame [y:y+h, x:x+w]
        roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
        roi_color = cv2.resize(roi_color, (image_size, image_size))
        image = roi_color.astype(np.float32, copy=False)
        image = np.expand_dims(image, axis=0)
        image = preprocess_input(image, version=1) # or version=2
        preds = model.predict(image)
        predicted_class=np.argmax(preds,axis=1)

        labels = dict((v,k) for k,v in labels.items())
        name = [labels[k] for k in predicted_class]

        cv2.putText(cam_frame,str(name), 
                    (x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
        
    cv2.imshow('video image', cam_frame)
    key = cv2.waitKey(30)
    if key == 27: # press 'ESC' to quit
        break

camera.release()
cv2.destroyAllWindows()

อันไหนดีกว่า? Keras หรือ Tensorflow

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

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

หากคุณต้องการเริ่มต้นทำงานกับการเรียนรู้เชิงลึกที่ไม่ซับซ้อนมากนัก ให้ใช้ Keras เนื่องจาก Keras ให้ความเรียบง่ายและเป็นมิตรต่อผู้ใช้และง่ายต่อการนำไปใช้งานมากกว่า Tensorflow แต่หากคุณต้องการเขียนอัลกอริทึมของคุณเองในโครงการหรือการวิจัยการเรียนรู้เชิงลึก คุณควรใช้ Tensorflow แทน

สรุป

มาสรุปทุกสิ่งที่เราได้พูดคุยและทำในบทช่วยสอนนี้กัน

• Keras ใน API ระดับสูงที่ใช้เพื่อทำให้เครือข่ายการเรียนรู้เชิงลึกง่ายขึ้นด้วยความช่วยเหลือของกลไกแบ็กเอนด์
• Keras ใช้งานง่ายและเข้าใจง่ายด้วยการรองรับ Python ดังนั้นจึงให้ความรู้สึกเป็นธรรมชาติมากกว่าที่เคย เหมาะสำหรับผู้เริ่มต้นที่ต้องการเรียนรู้เกี่ยวกับการเรียนรู้เชิงลึกและสำหรับนักวิจัยที่ต้องการ API ที่ใช้งานง่าย
• กระบวนการติดตั้งนั้นง่ายดาย และคุณสามารถใช้สภาพแวดล้อมเสมือนหรือใช้แพลตฟอร์มภายนอก เช่น AWS.
• Keras ยังมาพร้อมกับโมเดลเครือข่ายหลายประเภท ดังนั้นจึงทำให้เราใช้โมเดลที่มีอยู่ได้ง่ายขึ้นสำหรับการฝึกอบรมล่วงหน้าและการปรับแต่งโมเดลเครือข่ายของเราเอง
• นอกจากนี้ยังมีบทช่วยสอนและบทความมากมายเกี่ยวกับการใช้ Keras จากโค้ดชุมชนทั่วโลกเพื่อวัตถุประสงค์ในการเรียนรู้เชิงลึก