โปรแกรมจดจำใบหน้า เขียนได้ง่ายๆ จริงหรือ?
ถ้าคุณกำลังศึกษา Machine Learning คุณน่าจะเคยได้ยินเกี่ยวกับโปรแกรมจดจำใบหน้าแน่นอน ถ้าหากคุณค้นหาใน google ด้วยคำว่า “face recognition” หรือ “โปรแกรมจดจำใบหน้า” คุณก็จะเห็นคนมากมาย ที่ทำวีดีโอ หรือบทความตัวอย่างเพื่อสอนเรื่องนี้ ซึ่งถ้าคุณได้ลองเข้าไปดู จะเห็นว่าโค้ดมันสั้นนิดเดียว น่าจะเป็นเรื่องที่ง่ายใช่ไหมละ บางคนก็ทำวีดีโอให้ดู เขียนแป๊บเดียวไม่ถึง 20 นาทีก็เสร็จ แถมบอกว่าทำได้ง่ายๆ อีก สรุปว่าโปรแกรมจดจำใบหน้านี้มันทำได้ง่ายขนาดนั้นเลยใช่ไหม มันทำง่ายแบบนั้นจริงเหรอ ถ้าคุณอยากรู้ อ่านต่อไปได้เลยครับ
ในบทความนี้ผมจะสอนเขียนโปรแกรมจดจำใบหน้าใช่ไหม
คำตอบคือ….ไม่ครับ
ถ้าคุณอยากได้โค้ดโปรแกรมจดจำใบหน้า ลองหาใน google ดูนะครับ มีคนสอนเยอะแยะ ส่วนในบทความนี้ ผมจะมาเขียนอธิบาย ขั้นตอนการทำโปรแกรมจดจำใบหน้าให้อ่านกันครับ คุณจะได้รู้ว่ามันง่ายอย่างที่เขาว่ากันหรือเปล่า แล้วการเขียนโปรแกรมจดจำใบหน้ามันยากตรงส่วนไหน
การทำโปรแกรมจดจำใบหน้ามีขั้นตอนอะไรบ้าง
ผมคิดว่าเรื่องนี้เป็นสิ่งสำคัญที่ทุกคนควรทำความเข้าใจก่อนจะเริ่มเขียนโปรแกรมจดจำใบหน้านะครับ เพราะถ้าคุณไม่เข้าใจลำดับขั้นตอนพวกนี้ คุณก็จะไม่รู้ว่าคุณจะต้องเริ่มเขียนอะไรก่อน และจะเขียนอะไรในลำดับถัดไป ซึ่งในบทความนี้ ผมจะอธิบายให้ฟังตั้งแต่ขั้นตอนแรก จนถึงขั้นตอนสุดท้ายเลยครับ มาดูกันเลย
ขั้นตอนที่ 1 หารูปภาพ
แน่นอนว่าเราต้องหารูปภาพมาก่อน เพราะเราจะทำโปรแกรมจดจำใบหน้า (จากรูปภาพ) ไงละ แต่บางคนก็อาจจะบอกว่า ผมจะทำในวีดีโอครับ หรือไม่ก็ให้มันทำงานแบบรีลไทม์โดยรับข้อมูลจากกล้อง
1.1 ภาพนิ่งและวีดีโอแตกต่างกันอย่างไร
ผมต้องอธิบายอย่างนี้นะครับว่า ไม่ว่าจะเป็นวีดีโอ หรือวีดีโอแบบรีลไทม์ที่ได้จากกล้อง ข้อมูลพวกนี้ถ้าจะพูดจริงๆ แล้วมันก็คือ การนำภาพนิ่ง มาเล่นต่อกันด้วยความเร็วสูงนั่นเองครับ ซึ่งคุณน่าจะเคยได้ยินคำว่า FPS ซึ่งมันย่อมาจากคำว่า Frame per sec เช่น 60 fps หมายความว่า วีดีโอนี้เล่นด้วยความเร็ว 60 ภาพต่อวินาที ซึ่งมันก็จะทำให้เรามองเห็นการเคลื่อนไหวที่สมูทและต่อเนื่องมากขึ้น โดยปกติตาของคนเรา จะเริ่มแยกแยะระหว่างภาพนิ่ง กับภาพเคลื่อนไหว ไม่ได้เมื่อภาพนิ่งนั้นเล่นด้วยความเร็ว 25 ภาพต่อวินาที ดังนั้นวีดีโอส่วนใหญ่ จึงมีความเร็วในการเล่นอยู่ที่ 30 fps หรือ 30 ภาพต่อวินาทีนั่นเองครับ แล้วถ้าเล่นช้ากว่า 25 fps ละ? ผลลัพธ์ก็คือ เราจะวีดีโอนั่นกระตุกนั่นเองครับ
ซึ่งในการประมวลผลวีดีโอ หรือวีดีโอแบบรีลไทม์จากกล้อง เราก็จะต้องดึงภาพออกมาประมวลผลทีละภาพ ดังนั้นการประมวลผลวีดีโอ ก็คือการวนลูปประมวลผลภาพนิ่งนั่นเองครับ
1.2 เราจะหาภาพได้จากที่ไหน
ถ้าคุณอยากทดสอบโปรแกรม ผมแนะนำว่าหาภาพดาราจากในเน็ตมาทดสอบดูก่อนก็ได้ครับ แล้วจะต้องใช้กี่ภาพละ?
โดยปกติก็ไม่ควรจะต่ำกว่าคนละ 1000 ภาพแหละครับ แต่ถ้าได้น้อยกว่านี้ก็ไม่เป็นไร คือถ้าภาพเราเยอะ โปรแกรมเราก็จะเรียนรู้ได้แม่นยำขึ้น
ก็แค่เซฟภาพจากในเน็ตแค่นั้นเอง ไม่น่าจะยากใช่ไหมละ? ใช่ครับ มันไม่ยากอย่างที่คุณคิดนั่นแหละ แต่คุณจะอดทนนั่งคลิกขวาแล้วเลือก save as… ไหวไหมแค่นั้นแหละ มันไม่ใช่ 1 หรือ 2 ภาพนะ แต่เป็นหลัก 100 หรือหลัก 1000 เป็นไงละครับ เริ่มเหงื่อตกกันแล้วใช่ไหมละ แต่ไม่ต้องตกใจไป ผมมีวิธีโหลดภาพง่ายๆ จาก google มาฝาก เพียงแค่คลิก 2–3 ครั้ง คุณก็จะสามารถโหลดรูปภาพได้หลายร้อยรูปเลยละ อยากรู้ว่าทำยังไงใช่ไหมละ คลิกเข้าไปดูที่นี่เลย “วิธีดาวโหลดภาพจาก google”
แต่ถ้าเราทดสอบโปรแกรมเสร็จแล้ว เตรียมนำไปใช้งานจริง เราก็ต้องเอากล้องไปถ่ายคนจริงๆ ที่จะใช้โปรแกรมเลยนะครับ อยากให้โปรแกรมรู้จักใครบ้าง ถ่ายเอามาให้หมด ยิ่งถ่ายมาเยอะยิ่งดี
ขั้นตอนที่ 2 เตรียมรูปภาพ
หลังจากที่เราได้รูปภาพมาแล้ว ไม่ใช่ว่าจะเอาไปเข้าโปรแกรมได้เลยนะครับ แต่ต้องเตรียมรูปภาพก่อน โดยมีขั้นตอนย่อยดังนี้
2.1 จัดหมวดหมู่ภาพ
โดยให้ทำเป็นโฟลเดอร์ชื่อว่า dataset (จะใช้ชื่ออื่นก็ได้นะ แต่ส่วนมากเขาจะใช้ชื่อนี้กัน) แล้วทำเป็นโฟลเดอร์ย่อยแยกเก็บภาพของแต่ละคน แล้วก็ตั้งชื่อโฟลเดอร์ตามชื่อคนในภาพ ประมาณนี้
อย่างเช่นในโฟลเดอร์ “aum” ผมก็เก็บรูป “อั้ม พัชราภา” เอาไว้ ซึ่งขั้นตอนนี้ไม่มีตัวช่วยนะครับ คุณต้องมานั่งแยกเองว่า รูปนี้รูปใคร แต่ถ้าคุณใช้โปรแกรมนี้ “วิธีดาวโหลดภาพจาก google” ก็จะช่วยประหยัดเวลาได้อีกพอสมควร เพราะคุณจะได้รูปภาพที่กรองมาจาก google แล้วรอบหนึ่ง (เวลาคุณค้นหาใคร คุณก็ต้องพิมพ์ชื่อเขาใส่เข้าไปใช่ไหมละ แล้ว google ก็จะคัดเฉพาะภาพของคนนั้นมาให้ ซึ่งแม้ว่าจะมีภาพอื่นปนมาด้วยบ้าง แต่ก็ช่วยประหยัดเวลาเราไปได้เยอะเหมือนกัน)
2.2 ลบภาพที่ใช้ไม่ได้
“ภาพที่ใช้ไม่ได้” คือภาพอะไร มันก็คือภาพที่มีหลายใบหน้านั่นเองครับ เพราะตอนนี้เรากำลังจะสอนโปรแกรมว่า “นี่คือรูปของใคร” ดังนั้นในรูปนั้นก็ควรจะมีแค่คนนั้นเพียงคนเดียว ถ้ามีคนอื่นปนมาด้วย โปรแกรมก็จะเข้าใจผิด ดังนั้นขั้นตอนนี้ก็ต้องใช้คนดู แล้วไล่ลบไปทีละภาพอีกเหมือนเคยครับ ซึ่งก็ไม่ยากใช่ไหมละ แต่มันก็เสียเวลาทำนานอยู่เหมือนกัน
หรือถ้าเกิดว่ารูปภาพเรามีน้อย ไม่อยากลบออก ก็ใช้วิธีเขียนโปรแกรมตรวจจับใบหน้า แล้วให้โปรแกรมตัดเอาเฉพาะหน้าคนนั้นออกมาจากภาพก็ได้ครับ (เวลาตัดก็เผื่อดระยะขอบด้วยนะ)
ขั้นตอนที่ 3 ไปโหลดไลบารี่มาใช้
ตรงนี้ขึ้นอยู่กับว่าคุณจะเขียนภาษาอะไรครับ ก็ไปค้นหาไลบารี่ของภาษานั้น ถ้าเกิดหาไม่เจอ ก็แสดงว่า คนทั่วไปเขาไม่ใช้ภาษานี้กัน (สำหรับโปรแกรมจดจำใบหน้า) ซึ่งอาจเป็นเพราะว่าภาษานั้นไม่ได้ออกแบบมาทำอย่างนี้ หรือไม่ก็ช้าเกินไป (ยกตัวอย่างเช่น ภาษา HTML ผมไม่เคยเห็นใครเขาเอามาเขียนโปรแกรมจดจำใบหน้านะ) คุณก็ต้องเปลี่ยนไปใช้ภาษาที่คนทั่วไปเขาใช้กันครับ ถ้าให้ผมแนะนำเลยก็ Python ครับ เป็นภาษาที่เขียนง่าย และเป็นที่นิยมมากที่สุดในโลกแล้วตอนนี้
แต่ถ้าคุณใช้ MATLAB มันก็จะมี toolbox มาให้อยู่แล้วครับ สามารถเปิดดูตัวอย่างใน help ของโปรแกรมได้เลย หรือจะเข้าไปดูจากที่นี่ก็ได้ “What Is Image Recognition”
ขั้นตอนนี้ดูเหมือนจะไม่มีอะไรใช่ไหมละ แต่จริงๆ คือหัวใจหลักของโปรแกรมนี้เลยนะครับ เพราะอะไร ไปดูกันครับ
ก่อนอื่น คุณจะต้องเข้าใจก่อนว่า โปรแกรมจดจำใบหน้ามันมีขั้นตอนการทำงานยังไง ทำไมมันถึงจำรูปหน้าคนได้ ผมขอสรุปมาเป็นข้อๆ ตามนี้เลยละกัน
3.1 ขั้นตอนการทำงานของโปรแกรมจดจำใบหน้า
3.1.1 ตรวจหาตำแหน่งใบหน้าในรูปภาพ
แน่นอนว่า ก่อนจะให้โปรแกรมจดจำใบหน้าได้ เราก็ต้องให้โปรแกรมมันรู้ให้ได้ก่อนว่า ใบหน้าอยู่ตรงไหนภายในภาพ ซึ่งวิธีทำให้โปรแกรมมันรู้จักใบหน้า ก็ไม่ใช่ง่ายๆ อีก กระบวนการนี้เขาเรียกว่า object detection ครับ ซึ่งวิธีที่นิยมใช้กันก็จะมี Cascade object detection, Keras, TensorFlow, Deep Neural Network (DNN) ซึ่งไม่ว่าคุณจะเลือกใช้วิธีไหน ก็ยากไม่แพ้กันทั้งนั้นครับ
แต่โชคดีหน่อยที่เรากำลังจะทำโปรแกรมตรวจจับใบหน้า ซึ่งเป็นเรื่องที่มีคนสนใจเยอะ ดังนั้นตัวตรวจจับใบหน้านี้ จึงมีคนเทรนเอาไว้ให้เราเรียบร้อยแล้ว เราสามารถโหลดมาใช้งานได้เลย (คนที่เทรนตัวตรวจจับใบหน้านี่เขาใช้รูปภาพจำนวน 3 ล้านรูปในการเทรนเลยนะครับ กว่าจะได้ตัวตรวจจับที่มีความแม่นยำอย่างที่เราเห็น) เราก็เลยประหยัดเวลาในขั้นตอนนี้ไปได้เยอะเลยทีเดียว
แต่ถ้าหากสิ่งที่คุณอยากจะตรวจจับเป็นอย่างอื่นที่ไม่ใช่ใบหน้า อย่างเช่น ผลไม้บางชนิด ที่ไม่เคยมีใครเทรนตัวตรวจจับเอาไว้ นั่นแหละครับงานเข้าแล้ว คุณต้องไปเริ่มทำตัวตรวจจับเองตั้งแต่เริ่มต้นเลย ซึ่งผมบอกได้เลยว่า ถ้าเขียนอธิบายออกมา ก็ยาวไม่แพ้บทความนี้แน่นอน
3.1.2 แยกฟีเจอร์ หรือ สกัดฟีเจอร์จากรูปภาพ
คือคุณต้องเข้าใจนะครับว่ารูปภาพดิจิตอลที่เราเห็นอยู่ในคอมทั้งหมดนี่ คอมมันไม่ได้เห็นเป็นรูปภาพเหมือนเรานะ แต่มันเห็นเป็นชุดของตัวเลข 3 มิติ (รายละเอียดไม่ขอกล่าวถึงในบทความนี้ละกันครับ เดี๋ยวจะยาว) ดังนั้นเราจึงต้องบอกโปรแกรมก่อนว่าจะให้มันเรียนรู้ข้อมูลอะไรบ้าง ซึ่งข้อมูลนี้เราเรียกว่า “คุณลักษณะ” หรือ “ฟีเจอร์” ของภาพ ถ้าแบบง่ายสุด ก็เอาข้อมูลทุกพิกเซลมาให้โปรแกรมเรียนรู้เลย แบบนี้เรียกว่าการใช้พิกเซลเป็นฟีเจอร์ของภาพ วิธีนี้ง่ายก็จริง แต่ประสิทธิภาพไม่ดีหรอกครับ ยิ่งถ้ารูปภาพใหญ่ จำนวนฟีเจอร์ก็จะเยอะตามไปด้วย พอข้อมูลเยอะขึ้นโปรแกรมก็จะคำนวณช้าลง ในปัจจุบันก็เลยไม่มีใครข้อมูลพิกเซลมาทำเป็นฟีเจอร์ตรงๆ กันแล้ว
ถ้างั้นเราควรจะใช้ฟีเจอร์อะไรดีละ ถ้าคุณไปโหลดไลบารีมาใช้ คุณไม่ต้องกังวลเรื่องนี้หรอกครับ เพราะคุณไม่มีสิทธิ์เลือก ตรงส่วนนี้เขาจะทำเอาไว้ให้คุณใช้แล้ว
แล้วฟีเจอร์แต่ละประเภท ประสิทธิภาพมันเท่ากันเหรอ? แล้วฟีเจอร์ที่ไลบารี่ใช้มันดีที่สุดแล้วเหรอ? ตรงจุดนี่แหละครับที่มันเป็นปัญหา
ฟีเจอร์มีอยู่หลายประเภท แต่ละประเภทก็มีวิธีการคำนวณแตกต่างกัน เช่น HOG ฟีเจอร์ หรือ Histogram of oriented gradients เขาก็มีวิธีการคำนวณของเขา ใครอยากรู้ว่าคำนวณยังไง คลิกเข้าไปดูที่นี่นะ หรือบางคนก็อาจจะใช้ Haar like feature หรืออาจจะใช้วิธีอื่นๆ ก็ได้มีวิธีให้เลือกอยู่เยอะแยะมากมายเลยละ อยากรู้ก็ไปดูที่นี่ละกัน ซึ่งไม่ว่าจะเป็นฟีเจอร์ไหน ก็ล้วนคำนวณมาด้วยสมการคณิตศาสตร์ที่ซับซ้อนกันทั้งนั้น ถ้าคุณไม่ชอบคณิตศาสตร์ละก็ รับรองปวดหัวแน่นอน
แต่ปัญหาคือ ไม่ใช่ว่าทุกฟีเจอร์มันจะเหมาะกับการใช้จดจำใบหน้า ผมยกตัวอย่างให้เห็นภาพง่ายๆ ละกัน
สมมุติว่าตัวคุณเองเป็นโปรแกรมคอมพิวเตอร์ ที่กำลังจะเรียนรู้จากข้อมูล เพื่อจำแนกว่าใครสวย หรือไม่สวย แต่ถ้าข้อมูลที่คุณได้มาคือ บ้านเลขที่ ทะเบียนรถ วันเดือนปีเกิด จังหวัดที่เกิด อาหารที่ชอบ แบบนี้คุณจะบอกได้ไหมละว่าคนคนนี้สวยหรือไม่สวย ทั้งๆ ที่ข้อมูลพวกนี้ ก็นับว่าเป็นฟีเจอร์ของคนคนนั้นเหมือนกัน
ดังนั้น จึงไม่ใช่ว่าทุกฟีเจอร์มันจะมีความสัมพันธ์ กับผลลัพธ์ที่เราอยากให้โปรแกรมเรียนรู้ ซึ่งถ้าหากฟีเจอร์และผลลัพธ์มันไม่สัมพันธ์กัน เมื่อเทรนออกมาแล้ว โปรแกรมก็จะขาดความแม่นยำ มันก็เหมือนกับเราสอนข้อมูลผิดๆ ให้โปรแกรมนั่นแหละครับ จะให้โปรแกรมตอบเราให้ถูกต้องมันก็เป็นไปไม่ได้
แล้วเราจะรู้ได้ไงละว่าฟีเจอร์สัมพันธ์กับผลลัพธ์รึเปล่า คำตอบคือ… ไม่รู้หรอกครับ เพราะมนุษย์ กับคอมพิวเตอร์ มองเห็นไม่เหมือนกัน เราพอจะคาดเดาได้ ก็หลังจากที่เทรนโปรแกรมเสร็จโน่นแหละ ซึ่งถ้าเป็นแต่ก่อน เราก็ต้องลองเทรน ถ้าผลมันยังไม่ดี ก็ต้องเปลี่ยนฟีเจอร์ใหม่ แล้วเทรนไปเรื่อยๆ จนกว่าจะเจอฟีเจอร์ที่ใช้ได้ เสียเวลาและลำบากใช่เล่นเลยแหละ และด้วยเหตุนี้นี่เอง มันจึงเกิด Deep Neural Network ขึ้นมา ในเมื่อเราไม่รู้ว่าฟีเจอร์อันไหนดี งั้นก็ให้โปรแกรมมันคำนวณหาฟีเจอร์เอาเองเลยแล้วกัน จึงเป็นเหตุผลว่า ทำไม Deep Neural Network จึงให้ผลลัพธ์ที่แม่นยำกว่า Neural Network ธรรมดาทั่วไป แต่ก็ต้องแลกมาด้วยระยะเวลาการเทรนที่นานขึ้น รวมทั้งสเปคคอมที่ใช้เทรน ก็ต้องแรงด้วย
3.1.3 เลือกวิธีการที่จะใช้เทรน
วิธีการพวกนี้มีอยู่หลายวิธีมากครับ เราเรียกรวมๆ กันว่าเป็น Machine Learning หรือก็คือ เป็นวิธีการที่ทำให้โปรแกรม มันสามารถเรียนรู้ได้เองจากข้อมูลที่ใส่เข้ามา
ผมคิดว่าทุกคนน่าจะได้ยินคำนี้บ่อยแหละ “ให้โปรแกรมมันเรียนรู้เอง” แต่คุณรู้ไหมว่า โปรแกรมมันเรียนรู้ยังไง? แล้วโปรแกรมมันจำได้ยังไง โปรแกรมมันเปลี่ยนโค้ด หรือเขียนโค้ดให้ตัวเองได้เหรอ? ถ้าตอนเริ่มต้นเราเขียน if-else เอาไว้ 10 ตัว พอให้โปรแกรมเรียนรู้เองมันจะเขียนเพิ่มเป็น 100 ตัวแบบนี้รึเปล่า
คำตอบคือ… เปล่าครับ ไม่ใช่แบบนั้น
ผมขออธิบายสั้นๆ แล้วกันครับว่า “โปรแกรมมันเรียนรู้ โดยการปรับค่าน้ำหนัก” ยกตัวอย่างง่ายๆ นะครับ
if A*B>1:
print("Yes")
else:
print("No")สมมุติว่าเราเขียนโค้ดโปรแกรมเอาไว้เหมือนตัวอย่างด้านบน พอเราเทรนโปรแกรมเสร็จ โค้ดของเราก็จะยังหน้าตาเหมือนเดิมแบบนี้แหละครับ เพียงแต่ว่าผลลัพธ์ที่ได้มันจะต่างออกไปจากเดิม ทำไมถึงเป็นอย่างนั้นละ?
สมมุติว่า A คือ input ที่เราป้อนเข้าไปนะครับ สมมุติว่ามันรูปลิซ่าแล้วกัน จากตัวอย่างโปรแกรม แปลเป็นภาษาคนก็จะได้ประมาณว่า ถ้ารูปที่ป้อนเข้ามาคือรูปลิซ่า ให้ตอบ Yes ถ้าไม่ใช่ให้ตอบ No เมื่อเราป้อนรูปลิซ่าเข้าไป แล้วบอกโปรแกรมว่า “ถ้า input เป็นแบบนี้ให้ตอบ Yes นะ โปรแกรมมันก็จะพยายามปรับค่า B ให้เพิ่มขึ้นเรื่อยๆ จนกระทั่ง A*B มากกว่า 1 พอตรงกับคำตอบแล้ว โปรแกรมก็จะเอารูปต่อไปเข้ามา แล้วพยายามปรับค่าให้ได้ตรงกับคำตอบที่เรากำหนดอีกครั้ง ทำแบบนี้วนซ้ำไปเรื่อยๆ นี่แหละครับ ที่เรียนกว่า “การเรียนรู้ของโปรแกรม”
เมื่อโปรแกรมเรียนรู้เสร็จ มันก็จะได้ค่าน้ำหนักออกมาชุดหนึ่ง เราก็บันทึกค่าพวกนั้นเอาไว้ เพื่อเอาไปใช้งานต่อได้เลย เพราะแบบนี้เราจึงไม่จำเป็นต้องเทรนโปรแกรมใหม่ทุกครั้งที่จะใช้งานนั่นเองครับ
แต่ชีวิตจริง มันก็ไม่ได้ง่ายขนาดนั้น วิธีการแต่ละวิธี ก็เหมาะกับฟีเจอร์คนละแบบ ซึ่งเราไม่รู้หรอกว่าอันไหนเหมาะกับอันไหน เราทำได้แค่ทดสอบ และดูผลลัพธ์ ถ้ามันออกมาไม่ได้ ก็เปลี่ยนวิธีใหม่ เทรนใหม่ ทดสอบใหม่ ทำซ้ำแบบนี้ไปเรื่อยๆ จนกว่าจะได้ผลลัพธ์ที่ดี ซึ่งตรงนี้แหละครับที่มันยาก
เพราะเราไม่รู้หรอกว่า ต้องแก้หรือปรับเปลี่ยนตรงไหน ถึงจะได้ผลลัพธ์ที่ดี เพราะแม้แต่ในปัจจุบันนี้ (ปี 2020) นักวิจัยก็ยังศึกษา ค้นคว้าวิจัยเรื่องนี้กันอยู่เลย มันจึงไม่มีวิธีการที่แม่นยำ และใช้ได้ผลแน่นอน เหมือนการเขียนโปรแกรมทั่วๆ ไป
ดังนั้นการเลือกฟีเจอร์ และวิธีการเทรน จึงเป็นส่วนที่ยากที่สุดของการทำโปรแกรมจดจำใบหน้า
แต่ก็อย่างที่บอก ถ้าหากคุณใช้ไลบารี่สำเร็จรูปที่มีคนอื่นเขาเขียนไว้แล้ว ก็ไม่จำเป็นต้องสนใจส่วนนี้ (แต่สุดท้ายก็ต้องได้กลับมาสนใจเหมือนเดิมแหละ) เพราะคุณไม่สามารถปรับเปลี่ยน หรือแก้ไขอะไรตรงส่วนนี้ได้ ดังนั้นถ้าเทรนแล้ว ผลลัพธ์มันออกมาไม่ได้ คุณก็ทำอะไรไม่ได้มากนัก นอกจากไปโหลดภาพตัวอย่างมาเพิ่ม ซึ่งผมบอกเลยว่า มันก็ไม่ได้ช่วยอะไรมากหรอก
แล้วสุดท้าย โปรแกรมของคุณก็จะวิเคราะห์ได้แค่ภาพตัวอย่าง ไม่กี่ภาพเท่านั้น เอาไปใช้งานจริงอะไรไม่ได้เลย เพราะผลลัพธ์มันไม่ได้แม่นยำอะไร แล้วคุณก็แก้ไขอะไรไม่ได้ด้วย
และนี่คือข้อจำกัดของการใช้ไลบารี่นั่นเองครับ โอเคมันเขียนง่าย เขียนเสร็จเร็วก็จริง แต่ก็ปรับแต่งอะไรไม่ค่อยได้ และวีดีโอสอน หรือบทความ ทั้งหมด ที่คุณเห็นในอินเตอร์เน็ต ที่เขาบอกว่าง่าย เขียนแป๊บเดียวเสร็จ ก็ล้วนแต่ใช้ไลบารี่แบบนี้กันทั้งนั้นครับ ซึ่งมันยังห่างไกลกับคำว่าใช้ได้จริงอีกเยอะ
3.2 การใช้ไลบารี่
จากหัวข้อ 3.1 ตอนนี้เรารู้แล้วว่ากว่าจะได้คำตอบออกมาจะต้องผ่านกระบวนการอะไรบ้าง แต่ถ้าคุณเลือกใช้ไลบารี่สำเร็จรูป (เหมือนที่เขาทำตัวอย่างกันให้ดูทั่วไปในเน็ต) คุณก็ไม่จำเป็นต้องไปสนใจขั้นตอนที่ 3.1 มากนักก็ได้ ถ้าคุณอยากปรับปรุงผลลัพธ์การเทรนให้มันดีขึ้นเมื่อไร ตอนนั้นค่อยกลับไปอ่านข้อ 3.1 แบบละเอียดก็ได้
ในหัวข้อนี้ ผมจะอธิบายถึงการใช้ไลบารี่เป็นหลักนะครับ แต่ไม่ยึดติดกับไลบารี่ตัวใดตัวหนึ่งเป็นพิเศษนะ จะกล่าวแบบรวมๆ เพราะไลบารี่ทุกตัวจะมีขั้นตอนการทำงานคล้ายกัน ดังนี้ครับ
3.2.1 รันโปรแกรม encode หรือโปรแกรมเข้ารหัส
โปรแกรมนี้จะทำหน้าที “เข้ารหัส” (หรือพูดง่ายๆ ก็คือแยกฟีเจอร์) ออกมาจากรูปภาพทั้งหมดที่เราเก็บไว้ใน dataset แล้วบันทึกไว้เป็นไฟล์ 1 ไฟล์ ซึ่งไฟล์คือจะเป็นตัวแทนรูปภาพทั้งหมดของเราใน dataset นั่นเอง
3.2.2 โหลดภาพตัวอย่างเข้ามาทดสอบ
ในกระบวนการนี้ นอกจะต้องโหลดภาพเข้ามาในโปรแกรมแล้ว ยังต้องโหลดข้อมูลอย่างอื่นด้วยครับ ซึ่งโดยรวมแล้วจะมีขั้นตอนดังนี้
- โหลดตัวตรวจจับใบหน้า
- โหลดไฟล์เข้ารหัสที่ได้จากข้อ 3.2.1
- ใช้ตัวตรวจจับใบหน้า มาค้นหาตำแหน่งของใบหน้า ในภาพทดสอบ
- ใช้ฟังก์ชันเข้ารหัส (มาพร้อมกับไลบารี่) เพื่อเข้ารหัสภาพ ตรงตำแหน่งที่ตรวจจับได้ (ซึ่งบางที ตำแหน่งนั้นก็อาจจะไม่ใช่ใบหน้าก็ได้)
- เอาข้อมูลเข้ารหัสที่ได้ มาเปรียบเทียบกับข้อมูลเข้ารหัสที่ทำเอาไว้จากข้อ 3.2.1
- เลือกเอาผลเปรียบเทียบ ที่มี % ความเหมือนมากที่สุดมาเป็นคำตอบ
ที่เหลือก็เป็นขั้นตอนการแสดงผลครับ นั่นก็คือตีกรอบส่วนที่คิดว่าเป็นใบหน้า แล้วก็ใส่ชื่อที่วิเคราะห์ได้เข้าไป แค่นั้นก็จบ
ขั้นตอนที่ 4 เพิ่มประสิทธิภาพให้โปรแกรมจดจำใบหน้า
ขั้นตอนนี้ ขั้นตอนพิเศษที่ทำให้โปรแกรมด้าน image processing หรือ computer vission แตกต่างจากโปรแกรมทั่วไป
โปรแกรมทั่วไป อย่างเช่นโปรแกรมขายสินค้า เว็บไซต์ หรือโปรแกรมฐานข้อมูลใดๆ แค่คุณทำให้โปรแกรมมันรันออกมาได้ แค่นั้นก็จบแล้วครับ ยกตัวอย่างเช่น โปรแกรมติดต่อฐานข้อมูล ถ้าคุณรันโปรแกรมได้ ก็แสดงว่า โปรแกรมอ่าน เขียน แก้ไข เพิ่มเติม ข้อมูลในฐานข้อมูลได้แล้ว ก็ไม่จำเป็นต้องทำอะไรเพิ่มเติมกับส่วนนี้อีก
แต่โปรแกรมด้าน image processing มันไม่ใช่แบบนั้น เพราะถึงแม้ว่าโปรแกรมมันจะรันออกมาได้ แต่คำตอบมันก็มักจะไม่ค่อยแม่น พูดง่ายๆ ก็คือไม่ตรงกับที่ตาคนมองเห็นนั่นแหละ ดังนั้นเราจึงจำเป็นต้องเพิ่มประสิทธิภาพให้โปรแกรม
ซึ่งส่วนนี้ มีน้อยมากที่จะเขาจะสอน หรือกล่าวถึงเอาไว้ในบทความ หรือวีดีโอ อย่างมากก็แค่ให้คำแนะนำเอาไว้ว่าต้องทำอย่างไร ซึ่งผมต้องบอกว่า….
ทั้งหมดนั้นเป็นแค่เพียงทฤษฎี ต่อให้คุณทำตามนั้นได้เป๊ะๆ ก็ใช่ว่าผลลัพธ์จะดีขึ้น
อ้าว…. ถ้างั้นแล้วเราจะทำให้ผลลัพธ์ดีขึ้นได้ไงละ
ตรงจุดนี้แหละครับ ที่มันเชื่อมโยงกลับไปที่ข้อ 3.1.1 ก่อนที่คุณจะปรับปรุงมันได้ คุณก็ต้องเข้าใจให้ได้ก่อนว่ามันทำงานยังไง
แล้วเมื่อคุณเข้าใจแล้วว่าโปรแกรมจดจำใบหน้าทำงานยังไง คุณก็จะเข้าใจต่อไปอีกว่า การปรับปรุงประสิทธิภาพของโปรแกรมจดจำใบหน้าให้ดีขึ้นนั้นยากแค่ไหน
สรุป
ถ้าใครอ่านมาถึงตรงนี้ แสดงว่าคุณคงจะสนใจเรื่องนี้อยู่จริงๆ เพราะขนาดผมเป็นคนเขียน ยังคิดว่ามันยาวมากเลย นี่ขนาดอธิบายแบบสั้นๆ แล้วด้วยนะ (บทความนี้ผมใช้เวลาเขียนเกือบทั้งวัน) ยังไงก็ขอขอบคุณผู้อ่านทุกท่านที่พยายามอ่านมาได้ถึงตรงนี้นะครับ
โดยสรุปก็คือ การเขียนโปรแกรมตรวจจับใบหน้า ที่เขาสอนกันทั่วไปในเน็ต และบอกว่าง่าย เขียนแป๊บเดียวเสร็จ ทั้งหมดนั้นเป็นแค่ขั้นตอนการทำงานในข้อ 3.2 เท่านั้น มันก็เลยดูเหมือนง่าย และเขียนได้เร็ว
แต่ถ้าหากคุณตั้งใจจะเขียนโปรแกรมจดจำใบหน้าเพื่อใช้งานจริงๆ ละก็ ทั้งหมดที่ผมเขียนมานี่ คือสิ่งที่คุณต้องเจอ แล้วถ้าหากคุณคิดว่า สิ่งที่ผมอธิบายไปนี่ยากมากแล้วละก็ ผมบอกเลยว่าการเขียนโปรแกรมจริง ยากกว่านี้สักพันเท่า และมันก็ยังมีเรื่องอื่นให้ต้องทำเพิ่มด้วย เช่น การตรวจสอบใบหน้า ว่าเป็นใบหน้าจริงหรือปลอม (รูปที่เปิดจากในโทรศัพท์หรือไอแพด)
แต่ถ้าหากคุณไม่อยากเสียเวลาพัฒนา ก็มี API และ SDK ของหลายบริษัท ที่ออกมาให้เราใช้งานได้ แต่ก็ต้องเสียเงินค่า license หรือค่าใช้บริการของเขาละนะ แต่ก็ใช่ว่า API หรือ SDK พวกนี้จะผลลัพธ์ดีเยี่ยมนะครับ ส่วนมากก็ยังใช้ไม่ค่อยได้ ที่พอใช้ได้จริงๆ มีอยู่แค่ไม่กี่เจ้าเท่านั้น
ถ้าอยากรู้ว่ามีเจ้าไหนให้บริการบ้าง คะแนนรีวิวของแต่ละเจ้าเป็นเท่าไร น่าใช้รึเปล่า ก็ลองเข้าไปดูรีวิวได้ที่นี่ครับ Top 10 Facial Recognition APIs & Software of 2020
