TensorFlow เป็นเครื่องมืออเนกประสงค์ในการสร้างโมเดลแมชชีนเลิร์นนิง
ในโพสต์นี้ เราจะดูวิธีสร้างระบบจดจำใบหน้าด้วย TensorFlow ซึ่งเป็นเฟรมเวิร์กแมชชีนเลิร์นนิงแบบโอเพนซอร์ส เราจะพูดถึงกระบวนการที่จำเป็นในการสร้างระบบจดจำใบหน้าที่ประสบความสำเร็จ ตั้งแต่การรวบรวมและเตรียมข้อมูลไปจนถึงการฝึกอบรมและประเมินแบบจำลอง
คุณจะได้รับประสบการณ์โดยตรงกับ TensorFlow เพื่อสร้างการจดจำใบหน้าด้วยความช่วยเหลือของข้อมูลโค้ดและตัวอย่างในโลกแห่งความเป็นจริง โปรดติดตามในขณะที่เราดำเนินการต่อไป
รู้เบื้องต้นเกี่ยวกับ TensorFlow
TensorFlow เป็นไลบรารีโอเพ่นซอร์สฟรี เป็นกล่องเครื่องมือทางคณิตศาสตร์เชิงสัญลักษณ์ที่ใช้กระแสข้อมูลและการเขียนโปรแกรมเชิงอนุพันธ์ คุณสามารถจัดการกับงานได้หลากหลายรวมถึงงานเชิงลึกด้วย เครือข่ายประสาท การอบรม
TensorFlow ทรงพลังและปรับเปลี่ยนได้ เป็นเครื่องมือที่ยอดเยี่ยมสำหรับการพัฒนาและ ปรับใช้โมเดลแมชชีนเลิร์นนิง. คุณสามารถสร้างแบบจำลองที่ซับซ้อนด้วยเลเยอร์หลายชั้นและการทำงานของเทนเซอร์ นอกจากนี้ โมเดลที่สร้างไว้ล่วงหน้าในไลบรารียังสามารถปรับแต่งตามความต้องการเฉพาะได้อีกด้วย
นอกจากนี้ TensorFlow ยังมีชุมชนผู้ใช้ขนาดใหญ่และขยายตัว ดังนั้นจึงมีข้อมูลและความช่วยเหลือมากมายสำหรับผู้ที่ยังใหม่ต่อแพลตฟอร์ม
TensorFlow เป็นที่นิยมสำหรับ เรียนรู้เครื่อง ส่วนหนึ่งเป็นเพราะมีเวิร์กโฟลว์แบบ end-to-end คุณจึงสร้าง ฝึก และปรับใช้โมเดลได้อย่างง่ายดาย มีเครื่องมือและกลยุทธ์สำหรับการปรับปรุงและปรับขนาดโมเดลให้เหมาะกับความต้องการเฉพาะ มันแตกต่างกันไปตั้งแต่การประมวลผลข้อมูลล่วงหน้าไปจนถึงการปรับใช้โมเดล
การจดจำใบหน้าคืออะไร?
การจดจำใบหน้าคือ วิสัยทัศน์คอมพิวเตอร์ งานที่ระบุตัวตนของบุคคลตามใบหน้า เทคนิคนี้จะจดจำลักษณะของใบหน้า เช่น รูปร่างและพื้นผิวของดวงตา จมูก และปาก
และจะเปรียบเทียบกับฐานข้อมูลของใบหน้าที่รู้จักเพื่อระบุคู่ที่ตรงกัน การจดจำใบหน้ามีการใช้งานหลายอย่าง รวมถึงระบบรักษาความปลอดภัย การจัดระเบียบภาพถ่าย และการพิสูจน์ตัวตนด้วยไบโอเมตริก
ความแม่นยำของอัลกอริธึมการจดจำใบหน้าเพิ่มขึ้นอย่างมากในช่วงไม่กี่ปีที่ผ่านมา อันเป็นผลมาจากความก้าวหน้าในการเรียนรู้ของเครื่อง
นำเข้าไลบรารีที่จำเป็น
ก่อนเริ่มดำเนินการใดๆ เราต้องนำเข้าไลบรารีที่จำเป็นสำหรับโมเดลของเรา Tensorflow (tf) ถูกนำเข้าและใช้เพื่อสร้างและฝึกโมเดล <(หน้า>
“numpy” ทำการคำนวณทางคณิตศาสตร์และประมวลผลข้อมูล
“matplotlib.pyplot” ถูกนำเข้าเป็น plt และใช้สำหรับ การสร้างแผนภูมิข้อมูลและการสร้างภาพข้อมูล.
ในที่สุด "ดึงคน lfw" ถูกนำเข้าจาก sklearn ชุดข้อมูลและใช้ในการโหลดชุดข้อมูลการจดจำใบหน้า ฟังก์ชันนี้เป็นส่วนหนึ่งของชุดเครื่องมือ scikit-learn ต้องขอบคุณฟังก์ชันนี้ที่เราไม่ต้องอัปโหลดชุดข้อมูลอื่น สิ่งนี้มีอยู่แล้วใน sckit-learn
และช่วยให้คุณเข้าถึงได้หลากหลาย ชุดข้อมูลสำหรับการเรียนรู้ของเครื่อง แอพพลิเคชั่น. ในสถานการณ์สมมตินี้ เราใช้วิธีดึงข้อมูลคน lfw เพื่อดึงชุดข้อมูล “Labeled Faces in the Wild” (LFW) ประกอบด้วยภาพถ่ายใบหน้าของผู้คนและป้ายกำกับที่ไปด้วยกัน
ไลบรารีเหล่านี้มีความสำคัญอย่างยิ่งในการปรับใช้และประเมินโมเดลการจดจำใบหน้าของเรา
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
การประมวลผลล่วงหน้าและการโหลดชุดข้อมูลการจดจำใบหน้า
ในส่วนนี้ เราใช้ฟังก์ชัน "ดึงคน lfw" เพื่อประมวลผลข้อมูลการจดจำใบหน้าล่วงหน้า อันดับแรก เราใช้ fetch lfw people ด้วยตัวเลือก “min faces per person=60” สิ่งนี้บ่งชี้ว่าเราต้องการรวมเฉพาะบุคคลในชุดข้อมูลที่มีภาพถ่ายอย่างน้อย 60 ภาพ ดังนั้น เรามั่นใจว่าโมเดลของเรามีข้อมูลเพียงพอในการเรียนรู้ นอกจากนี้ยังช่วยลดอันตรายจากการใส่มากเกินไป
จากนั้นข้อมูลและป้ายกำกับจากวัตถุใบหน้าจะถูกแยกและกำหนดให้กับตัวแปร X และ y X โฮล
ตอนนี้เราพร้อมที่จะฝึกโมเดลการจดจำใบหน้าโดยใช้ข้อมูลและป้ายกำกับที่ประมวลผลล่วงหน้าแล้ว
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
การแยกชุดการฝึกและการทดสอบ
ในขั้นตอนนี้ เราแบ่งชุดข้อมูลการจดจำใบหน้าของเราออกเป็นสองส่วนโดยใช้วิธีแบ่งการทดสอบรถไฟจากการเลือก sklearn.model เป้าหมายของการแบ่งนี้คือการประเมินประสิทธิภาพของโมเดลของเราหลังการฝึกอบรม
ฟังก์ชันการแบ่งการทดสอบรถไฟจะรับเป็นข้อมูลอินพุต X และป้ายกำกับ y และแบ่งเป็นชุดฝึกและชุดทดสอบ เราเลือกขนาดทดสอบ=0.2 ในตัวอย่างนี้ ซึ่งหมายความว่า 20% ของข้อมูลจะถูกใช้เป็นชุดการทดสอบและ 80% เป็นชุดการฝึกอบรม นอกจากนี้ เราใช้ Random state=42 เพื่อให้แน่ใจว่าข้อมูลจะถูกแบ่งอย่างสม่ำเสมอในแต่ละครั้งที่มีการดำเนินการโค้ด
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, random_state=42)
การเตรียมข้อมูล
จุดประสงค์ของการประมวลผลข้อมูลล่วงหน้าคือเพื่อเตรียมข้อมูลเข้าสู่โมเดล ข้อมูลได้รับการประมวลผลล่วงหน้าในรหัสนี้โดยการหารจุดข้อมูลแต่ละจุดด้วย 255
อะไรเป็นแรงบันดาลใจให้เราบรรลุเป้าหมายนี้ การทำให้เป็นมาตรฐานคือขั้นตอนการประมวลผลล่วงหน้าที่ใช้ในแมชชีนเลิร์นนิงเพื่อรับประกันว่าฟีเจอร์ทั้งหมดจะอยู่ในระดับเดียวกัน ในสถานการณ์สมมตินี้ การหารด้วย 255 จะปรับขนาดข้อมูลเป็นช่วง 0 ถึง 1 ซึ่งเป็นขั้นตอนการทำให้ข้อมูลรูปภาพเป็นปกติ
สิ่งนี้จะเพิ่มความเร็วของการบรรจบกันของโมเดลและสามารถเพิ่มประสิทธิภาพได้
X_train = X_train / 255.0
X_test = X_test / 255.0
การสร้างโหมด
เราต้องการระบุบุคคลที่ใบหน้าปรากฏในรูปภาพ ในกรณีนี้ เราจะใช้เครือข่ายที่เชื่อมต่ออย่างสมบูรณ์ ซึ่งมักเรียกว่าเครือข่ายหนาแน่น เป็นเครือข่ายประสาทเทียมที่ใช้ในการสร้างแบบจำลอง
เครือข่ายประสาทเทียมจำลองมาจากการทำงานของสมองมนุษย์และการจัดระเบียบ ประกอบด้วยโหนดการประมวลผลข้อมูลหรือเซลล์ประสาทที่เชื่อมโยงกัน เซลล์ประสาทแต่ละเซลล์ในเลเยอร์ในเครือข่ายหนาแน่นเชื่อมโยงกับเซลล์ประสาททุกตัวในเลเยอร์ด้านบน
โมเดลมีสี่ชั้นในรหัสนี้ ในการป้อนเข้าสู่เลเยอร์ถัดไป ข้อมูลอินพุตจะถูกทำให้แบนในเลเยอร์แรกเป็นอาร์เรย์หนึ่งมิติ เซลล์ประสาท 128 และ 64 ในสองชั้นต่อไปนี้มีการเชื่อมโยงอย่างสมบูรณ์
ฟังก์ชันการเปิดใช้งาน ReLU เป็นฟังก์ชันการเปิดใช้งานเฉพาะที่ใช้โดยเลเยอร์เหล่านี้ ด้วยวิธีนี้ เราสามารถรับแบบจำลองเพื่อเรียนรู้ความสัมพันธ์ที่ไม่ใช่เชิงเส้นระหว่างอินพุตและเอาต์พุต เลเยอร์สุดท้ายใช้ฟังก์ชันการเปิดใช้งาน softmax เพื่อคาดการณ์ และเป็นชั้นที่เชื่อมต่ออย่างสมบูรณ์กับเซลล์ประสาทมากเท่าที่มีชั้นที่มีศักยภาพ
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(62 * 47,)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(len(target_names), activation='softmax')
])
การรวบรวมแบบจำลอง
โมเดลถูกคอมไพล์โดยใช้ฟังก์ชัน "คอมไพล์" เราต้องเตรียมโมเดลสำหรับการฝึก ดังนั้น เราจะกำหนดเครื่องมือเพิ่มประสิทธิภาพ ฟังก์ชันการสูญเสีย และเมตริกที่จะใช้ในการประเมินแบบจำลอง
ในระหว่างการฝึกอบรม เครื่องมือเพิ่มประสิทธิภาพมีหน้าที่รับผิดชอบในการเปลี่ยนแปลงพารามิเตอร์ของแบบจำลอง เครื่องมือเพิ่มประสิทธิภาพ "อดัม" เป็นเทคนิคการเพิ่มประสิทธิภาพการเรียนรู้เชิงลึกที่ได้รับความนิยม
เราใช้ฟังก์ชันการสูญเสียเพื่อประเมินประสิทธิภาพของแบบจำลองในข้อมูลการฝึกอบรม เนื่องจากป้ายกำกับเป้าหมายเป็นจำนวนเต็มซึ่งสะท้อนถึงคลาสของภาพแทนที่จะเป็นเวกเตอร์ที่เข้ารหัสแบบร้อนเดียว ฟังก์ชันการสูญเสีย
สุดท้าย เรากำหนดเมตริกเพื่อประเมินแบบจำลอง ในกรณีนี้คือ "ความแม่นยำ"
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
การฝึกโมเดล
เราจะใช้ฟังก์ชัน "พอดี" เพื่อฝึกโมเดล
เราจะจัดเตรียมข้อมูลการฝึกอบรม (รถไฟ X) และป้ายกำกับที่เกี่ยวข้อง (รถไฟ y) รวมทั้งกำหนดจำนวนยุค (การวนซ้ำ) เพื่อเรียกใช้เป็น 10 ขั้นตอนการฝึกอบรมจะปรับเปลี่ยนน้ำหนักของแบบจำลองเพื่อลดการสูญเสีย (ความแตกต่างระหว่าง ฉลากที่คาดการณ์และจริง) และปรับปรุงความแม่นยำของข้อมูลการฝึกอบรม
model.fit(X_train, y_train, epochs=10)
การประเมินแบบจำลอง
ตอนนี้ เราจำเป็นต้องประเมินแบบจำลองที่ผ่านการฝึกอบรมจากข้อมูลการทดสอบ เราใช้การทดสอบการสูญเสียและความแม่นยำของการทดสอบเพื่อประเมินประสิทธิภาพของแบบจำลอง ในการทดสอบ data x test และ test label y test เราจำเป็นต้องเรียก "the model.evaluate function"
ฟังก์ชันแสดงผลความแม่นยำในการทดสอบและการสูญเสียการทดสอบ ตัวแปรทดสอบการสูญเสียและความแม่นยำในการทดสอบ ตามลำดับ มีค่าเหล่านี้ สุดท้าย เราใช้ฟังก์ชัน "พิมพ์" เพื่อส่งออกความแม่นยำในการทดสอบ
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
ทำนายคลาสและรับคลาสที่ทำนาย
การใช้รูปแบบการฝึกอบรมและข้อมูลการทดสอบ อัลกอริทึมทำการคาดคะเน เมื่อข้อมูลทดสอบถูกส่งผ่านไปยังเมธอด “model.predict” จะแสดงผลอาร์เรย์ของการคาดคะเนสำหรับแต่ละภาพในชุดทดสอบ
ชื่อคลาสเป้าหมายสำหรับแต่ละภาพจะถูกดึงมาจากรายการ "ชื่อเป้าหมาย" โดยใช้ฟังก์ชัน "np.argmax" เพื่อระบุดัชนีที่มีความน่าจะเป็นที่คาดการณ์ไว้มากที่สุด จากนั้นดัชนีนี้จะใช้เพื่อกำหนดคลาสที่คาดการณ์ไว้สำหรับแต่ละภาพ
เมื่อใช้ความเข้าใจในรายการ การคาดคะเนทั้งหมดในอาร์เรย์ "การคาดคะเน" จะต้องใช้วิธีนี้ ส่งผลให้เกิดรายการ "คลาสที่คาดการณ์"
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
การแสดงภาพการคาดการณ์
ตอนนี้เราสามารถดูได้ว่าโมเดลของเรามีลักษณะอย่างไร
เพื่อประเมินว่าตัวแบบทำงานได้ดีเพียงใด ภาพถ่าย 10 ภาพแรกและการคาดการณ์จะแสดงขึ้น มันจะลงจุดรูปภาพในโทนสีเทาและแสดงทั้งคลาสจริงของรูปภาพและคลาสที่โมเดลทำนายไว้โดยใช้โมดูล matplotlib.pyplot
ฟังก์ชัน "imshow" ถูกใช้โดย for loop เพื่อวางแผนภาพถ่ายชุดทดสอบ 10 ภาพแรกแต่ละภาพ ชื่อเป้าหมาย[y การทดสอบ[i]] และคลาสที่คาดการณ์[i] ใช้เพื่อกำหนดคลาสจริงและคลาสที่คาดการณ์ของภาพตามลำดับ ชื่อเรื่องของแต่ละโครงเรื่องจะถูกระบุด้วยการจัดประเภทเหล่านี้
สุดท้าย พล็อตจะแสดงโดยใช้เมธอด plt.show()
for i in range(10):
plt.imshow(X_test[i].reshape(62, 47), cmap='gray')
plt.title(f"True: {target_names[y_test[i]]}, Predicted:{predicted_classes[i]}")
plt.show()
สรุป
TensorFlow นำเสนอสภาพแวดล้อมที่สมบูรณ์และยืดหยุ่นสำหรับการสร้างโมเดลแมชชีนเลิร์นนิง
การปรับโมเดลให้ตรงตามความต้องการเฉพาะหรือโดยการเพิ่มการพัฒนาใหม่ในแมชชีนเลิร์นนิง ความแม่นยำของโมเดลอาจเพิ่มขึ้นไปอีก
TensorFlow และการจดจำใบหน้ามีแนวโน้มที่จะถูกนำมาใช้มากขึ้นในอุตสาหกรรมต่างๆ เช่น ระบบรักษาความปลอดภัย การพิสูจน์ตัวตนด้วยไบโอเมตริก และการดูแลสุขภาพในอนาคต เราจะได้เห็นนวัตกรรมที่น่าสนใจในไม่ช้า
เขียนความเห็น