เริ่มต้นเขียนโค้ดโปรแกรมการแยกแยะข้อมูลด้วยตนเอง
การเรียนรู้ของคอมพิวเตอร์ แมชชีนเลิร์นนิ่ง ตอนที่ 5
ในบทเรียนนี้เราจะมาทดลองทำบางสิ่งที่พิเศษกัน และจะมาเริ่มต้นเขียนโค้ดโปรแกรมที่สามารถแยกแยะข้อมูลได้ด้วยตัวเราเองจากปัญหาที่กำหนด
หากเรายังใหม่กับเรื่องราวของแมชชีนเลิร์นนิ่ง เรื่องที่เรากำลังจะทำต่อไปนี้เป็นสิ่งจำเป็นอย่างยิ่งที่จะทำให้เราเข้าใจเรื่องแมชชีนเลิร์นนิ่งหรือการเรียนรู้ของคอมพิวเตอร์ได้ดียิ่งขึ้น
Nearest Neighbor การเทียบเคียงกับข้อมูลใกล้เคียง
หากคุณสามารถเข้าใจในเรื่องที่จะได้กล่าวถึงต่อไปนี้ แสดงว่าคุณมีความรู้ความเข้าใจส่วนสำคัญของการทำแมชชีนเลิร์นนิ่ง
สำหรับโค้ดโปรแกรมเพื่อการแยกแยะข้อมูลในบทเรียนนี้ เป็นส่วนหนึ่งของ k-Nearest Neighbors หรือการแยกแยะด้วยวิธีการเทียบเคียงกับข้อมูลใกล้เคียง ซึ่งเป็นวิธีการแยกแยะข้อมูลแบบง่ายประเภทหนึ่ง
ก่อนอื่นเรามารู้จักกับขอบเขตของเนื้อหาในบทเรียนนี้กันก่อน เราจะมาเริ่มต้นเขียนโค้ดโปรแกรมของเราต่อจากโค้ดโปรแกรมที่เราได้เขียนไว้แล้วในตอนที่ 4 ในการเขียนไปป์ไลน์
ในบทเรียนนี้เราจะเริ่มต้นโค้ดโปรแกรมของเราด้วยตัวอย่างง่ายๆ เช่นเดียวกัน
เริ่มต้นด้วยการนำเข้าเซ็ตข้อมูลและแบ่งเซ็ตข้อมูลออกเป็นสองส่วนคือ ข้อมูลสำหรับสอน และข้อมูลสำหรับทดสอบ ตามโค้ดโปรแกรมในบรรทัดที่ 7 และ 8
ถัดไปเราจะใช้ข้อมูลที่แบ่งไว้เพื่อสอนคอมพิวเตอร์มาทำการสอนให้คอมพิวเตอร์เรียนรู้ดังนี้
และใช้ข้อมูลที่ได้แบ่งไว้เพื่อทดสอบความสามารถในการแยกแยะข้อมูล ว่ามีความถูกต้องแม่นยำเพียงใดดังนี้
การเขียนโค้ดโปรแกรมเพื่อทำหน้าที่แยกแยะข้อมูล มีส่วนที่เราจะมุ่งเน้นในบทเรียนนี้
จากไลบรารี่ sklearn เราจะทำการนำเข้าฟังก์ชั่นการแยกแยะข้อมูลด้วยการเทียบเคียงกับข้อมูลข้างเคียง KNeighborsClassifier() ดังตัวอย่างโค้ดโปรแกรมบรรทัดที่ 10 และ 11 เราจะมาเริ่มต้นเขียนโค้ดโปรแกรมด้วยตนเองโดยมีขั้นตอนดังต่อไปนี้
ขั้นตอนที่ 1 ให้ทำการคอมเม้นต์ส่วนที่นำเข้าเพื่อไม่ให้โค้ดโปรแกรมบรรทัดนั้นๆ ทำงาน
ขั้นตอนการทำไปป์ไลน์ยังคงเหมือนเดิม
เริ่มต้นด้วยการสั่งให้โปรแกรมจากบทเรียนที่แล้วทำงานเพื่อทบทวนความเข้าใจเกี่ยวกับไปป์ไลน์
ซึ่งจากการทำงานของโปรแกรมนี้ได้ผลลัพท์เป็น 0.92 หรือมีความถูกต้องในการทำนายที่ร้อยละ 92 ซึ่งมากกว่า ร้อยละ 90 ซึ่งมีความถูกต้องแม่นยำมากกว่าเป้าหมายที่เราได้ตั้งไว้
จากนั้นเราจะทำการคอมเม้นท์ โค้ดโปรแกรมบรรทัดที่เราไม่ต้องการให้ทำงาน
ด้วยการใส่เครื่องหมาย # ไว้ที่เริ่มต้นบรรทัด ดังตัวอย่างบรรทัดที่ 10
ขั้นตอนที่ 2 Implement a class การนำคลาสมาใช้
จากนั้นสิ่งแรกที่ต้องทำในการแก้ไขไปป์ไลน์ของเราเอง ก็คือการนำคลาสเพื่อการแยกแยะข้อมูลที่ต้องการ มาใช้งาน คลาสนั้นก็คือ ScrappyKNN โดยทำการเพิ่มโค้ดโปรแกรมไว้ที่บรรทัดแรก ดังนี้
จากนั้นให้ทำการแก้ไขโค้ดโปรแกรมไปป์ไลน์ตามที่เราต้องการ จากเดิมในบรรทัดที่ 14
แก้ไข KNeighborsClassifier() เป็น ScrappyKNN() ดังนี้
ขั้นตอนที่ 3 ทำความเข้าใจกับอินเตอร์เฟส หรือส่วนติดต่อ
ในขั้นตอนนี้เราจะมาพิจารณาว่าเราจำเป็นต้องนำ เมทธอด ใดมาใช้
ในบรรทัดที่ 14 นั้นมี my_classifier เป็นอินเตอร์เฟสของคลาสสิฟายเออร์หรือการแยกแยะ และหากดูโค้ดโปรแกรมในบรรทัดถัดไปเราพบว่ามีคำสั่งอยู่สองคำสั่งดังนี้
my_classifier.fit ที่ทำหน้าที่ สอน (traing)
และ my_classifier.predict ที่ทำหน้าที่ ทำนาย (predict)
จากนั้นเราจะย้อนกลับไปที่จุดเริ่มต้นของโปรแกรม เพื่อทำการประกาศ fit method ของเรา
ซึ่งในขั้นตอนนี้เป็นการกำหนด ฟีทเจอร์ และเลเบล สำหรับเซ็ตข้อมูล เป็นข้อมูลนำเข้า
จากนั้นให้เพิ่มพารามิเตอร์ สำหรับเมทธอดนั้น
จากนั้นให้ไปเพิ่ม predict method
โดยจะกำหนดพารามิเตอร์เพื่อการนำเข้าข้อมูลให้กับ เมทธอด predict และผลลัพท์ของการทำนายผลด้วยเลเบล
ขั้นตอนที่ 4 ทำให้ไปป์ไลน์ทำงาน
จากเป้าหมายที่เรากำหนดไว้ตั้งแต่เริ่มต้นคือการทำให้ไปป์ไลน์ทำงาน และเข้าใจว่าเมทธอดนี้ ทำงานอย่างไร ดังนั้นก่อนที่เราจะเริ่มเขียนโค้ดโปรแกรมเพื่อทำหน้าที่แยกแยะข้อมุลของเรา จำเป็นต้องมาทดลองทำบางสิ่งง่ายๆ กันก่อน
เราจะมาเขียนโค้ดโปรแกรมเพื่อทำการแยกแยะข้อมูลแบบสุ่ม (Random classifier)
และด้วยการสุ่ม ซึ่งหมายความว่าเราจะทำการเดาผลลัพท์
เริ่มต้นด้วยการเพิ่มโค้ดโปรแกรมบางอย่างลงในเมทธอด fit และ predict ดังนี้
ในเมทธอด fit เราจะทำการใส่ ข้อมูลสำหรับสอน ลงในคลาส
ซึ่งจะเห็นว่าเรามาเพิ่มในส่วนนี้ภายหลัง
จากนั้นเราจำเป็นต้องคืนค่าลิสต์ของผลการทำนาย ลงในเมทธอด predict
เนื่องจากพารามิเตอร์ X_test นั้น เป็นอะเรย์แบบสองมิติ หรือ ลิสต์ของลิสต์ นั่นเอง
ในข้อมูลแต่ละรายการประกอบด้วย ฟีทเจอร์ต่างๆ สำหรับตัวอย่างในการทดสอบแต่ละตัวอย่าง
ณ จุดนี้ ไปป์ไลน์ของเราก็จะกลับมาทำงานได้อีกครั้ง จากนั้น เราลองมาทดสอบไปป์ไลน์ของเราโดยสั่งให้โปรแกรมทำงาน
หลังจากการรันโค้ดโปรแกรมแล้ว จะพบว่าผลลัพท์แสดงค่าความถูกต้องแม่นยำในการทำนายผลอยู่ที่ 0.3466666667 หรือร้อยละ 34.66 ซึ่งเป็นผลลัพท์ที่ได้จากการสุ่มเลเบลหรือผลลัพท์จากข้อมูลที่ใช้สอน
จากประเภทของดอกไม้ในเซ็ตข้อมูล iris ที่นำมาใช้ทดสอบในครั้งนี้ เนื่องจากมีดอกไม้อยู่สามประเภทด้วยกันดังนั้นความถูกต้องจึงควรอยู่ที่ 33% แต่จากผลลัพท์ที่สุ่มได้ อยู่ที่ 34.66% ซึ่งมากกว่าเป้าหมาย
เมื่อถึงขั้นตอนนี้เราก็จะเข้าใจอิินเตอร์เฟสสำหรับคลาสสิฟายเออร์หรือการแยกแยะข้อมูล แต่ในขณะที่เราเริ่มต้นการทดลองนี้ เรากำหนดว่าอัตราความแม่นยำถูกต้องควรมากกว่า 90% ดังนั้นหากเราสามารถทำให้ได้ผลลัพท์ที่ดีกว่านี้ ได้อย่างไร
ขั้นตอนที่ 5 เริ่มต้น k-NN
เรามาเริ่มต้นใช้งานคลาสสิฟายเออร์ของเรากัน ซึ่งเป็นโมเดลบนพื้นฐานของ k-Nearest Neighbors (การเทียบเคียงกับข้อมูล k) ก่อนอื่นเรามาทำความเข้าใจก่อนว่าอัลกอริธึมหรือขั้นตอนวิธีนี้ทำงานอย่างไร
เรามาย้อนดูการแบ่งประเภทข้อมูลสีแดงกับสีเขียวจากบทเรียนที่แล้วกัน โดยสมมติให้จุดที่อยู่บนระนาบ xy ดังภาพนั้นก็คือข้อมูลสอน ซึ่งอยู่ในเมทธอด fit ในเซ็ตข้อมูลที่ใช้ในการทดสอบนี้
และหากเราต้องการทำนายผลข้อมูลจากข้อมูลสอนเหล่านี้ ตัวอย่างเช่นจุดสีเทา ซึ่งคอมพิวเตอร์ไม่เคยรู้จักมาก่อน เราจะสามารถแยกแยะข้อมูลจุดสีเทานี้ว่าควรเป็นสีเขียว หรือสีแดง ได้อย่างไร
ในการแยกแยะด้วยการเทียบเคียงกับข้อมูลข้างเคียง หรือ Nearest Neighbor Classifier เราจะหาวิธีการสอนเพื่อให้ใกล้เคียงกับผลลัพท์มากที่สุด
ซึ่งจุดนี้ก็คือจุดข้างเคียงที่ใกล้ที่สุด เราก็จะทำนายว่าจุดสีเทาที่เราต้องการทำนายนั้นน่าจะเป็นประเภทเดียวกันกับจุดข้างเคียงที่ใกล้ที่สุดนั่นเอง ซึ่งในกรณีนี้เราก็จะทำนายว่าจุดสีเทาควรเป็นประเภทสีเขียว
เนื่องจากจุดข้างเคียงที่ใกล้ที่สุดกับจุดสีเทานั้นเป็นสีเขียวนั่นเอง
ในกรณีที่แตกต่างออกไป หากเรามีจุดที่ต้องการทดสอบในตำแหน่งอื่น
เราจะทำนายจุดสีเทานี้ ว่าควรเป็นจุดสีแดงเนื่องจากจุดตัวอย่างที่ใกล้เคียงที่สุดนั้นเป็นสีแดง
อย่างไรก็ตาม ในกรณีที่จุดสีเทาที่เราต้องการทำนาย มีระยะอยู่ตรงกลางเช่นนี้ ซึ่งเมื่อวัดระยะทางจากจุดสีเทาไปยังจุดสีแดงใกล้เคียง กับจุดสีเขียวใกล้เคียงนั้น มีระยะทางเท่าๆ กัน
ในกรณีเช่นนี้ เราจะระบุว่าจุดสีเทานี้ ควรเป็นสีเขียวหรือสีแดงเมื่อเทียบกับจุดที่อยู่ใกล้เคียง
วิธีการแก้ไขปัญหาเช่นนี้ วิธีการหนึ่งที่สามารถทำได้คือใช้วิธีการสุ่ม อย่างไรก็ตามมีวิธีการอื่นที่ดีกว่า และวิธีนั้นก็คือ การกำหนดค่า k โดยที่ค่า k ก็คือจำนวนของจุดข้างเคียง ที่เราสามารถนำมาใช้แก้ไขปัญหานี้นั่นเอง
เมื่อเราต้องการทำนายผลในกรณีที่จุดที่ต้องการทำนาย มีระยะทางความห่างกับจุดใกล้เคียงทั้งสองกลุ่มเท่าๆ กัน เราจะใช้ค่า k โดยหาก k มีค่าเป็น 1 หมายถึงจุดใกล้เคียงที่ใช้สอนมีเพียงจุดเดียว แต่หากค่า k เป็น 3 หมายถึงจุดใกล้เคียงที่ใช้สอน มีจำนวน 3 จุด
ซึ่งจากในกรณีนี้ จุดใกล้เคียงที่เป็นสีเขียว มีจำนวน 2 จุด และจุดใกล้เคียงที่เป็นสีแดงมีเพียง 1 จุด ซึ่งจำนวนของจุดใกล้เคียงที่เป็นสีแดงมีจำนวนน้อยกว่าสีเขียว ดังนั้นในการทำนายว่าจุดสีเทาที่เกิดขึ้นใหม่นั้นควรเป็นจุดสีอะไร ก็จะใช้วิธีนับจำนวนจุดข้างเคียงที่มากกว่านั่นเองซึ่งในกรณีนี้ก็ควรจะเป็นสีเขียว
นอกจากนี้ยังมีรายละเอียดอื่นอีกสำหรับอัลกอริธึมนี้ แต่ความเข้าใจเบื้องต้นเท่านี้ก็เพียงพอต่อการเริ่มต้นแล้ว
ขั้นตอนที่ 6 การวัดระยะความห่าง
แน่นอนว่าขั้นตอนแรกในการทำตามอัลกอริธึมนี้คือ การค้นหาจุดของข้อมูลที่อยู่ใกล้เคียง ซึ่งเราสามารถทำได้ด้วยการวัดเส้นตรงเพื่อให้ทราบถึงระยะความห่างระหว่างจุดสองจุด เหมือนที่เราใช้ไม้บรรทัดวัด ซึ่งมีสูตรคณิตศาสตร์เพื่อใช้ในการวัดแบบนี้ เรียกว่า ระยะห่างของยูคลิด (Euclidean Distance) ซึ่งเป็นการวัดที่ดูเหมือนกับกฏของไพธากอรัส (Pythagorean Theorem) A2 + B2 = C2
นอกจากนี้เรายังสามารถหาระยะห่างระหว่างจุดสองจุดได้ด้วยวิธี x2-x1
โดยการใช้ฟีทเจอร์ทั้งสองในการทำนวณ เพื่อหาความแตกต่างของระยะทางระหว่างจุดสองจุด
จากสูตรทางคณิตศาสตร์นี้ ทำให้เราสามารถทราบได้ว่า ระยะห่างระหว่างจุด a ไป b นั้นมีระยะทางเท่าไร เมื่อ a(x1, y1) และ b(x2, y2) คือตำแหน่งของจุด a และ b บนระนาบ xy
ต่อไปเรามาลองคำนวณระยะห่างระหว่างจุดสองจุดกัน เนื่องจากเรามีฟีทเจอร์เพียง 2 ฟีทเจอร์ คือ x และ y ในเซ็ตข้อมูลในการทดลองนี้ ซึ่งเป็นระนาบสองมิติ แต่หากเราต้องคำนวณจุดสองจุดที่อยู่บนระนาบสามมิติหรือมากกว่า จะทำอย่างไร ซึ่งในกรณีสามมิติจะอยู่ในรูปลูกบาศ
เรายังสามารถคำนวณหาระยะห่างระหว่างจุดสองจุดได้ แม้จะมีมิติมากกว่าสองมิติ หรือมีฟีทเจอร์มากกว่าสอง เช่นด้วยไม้บรรทัด
แต่หากมี 4 ฟีทเจอร์ หรือ 4 มิติ ดังเช่น เซ็อข้อมูล iris ซึ่งมีทั้งหมด 4 ฟีทเจอร์ เราจะคำนวณระยะทางได้อย่างไร ในกรณีจะเห็นว่าเป็นลักษณะแบบ ลูกบาศก์เชิงซ้อน (Hypercube) ซึ่งไม่สามารถนำเสนอให้เห็นภาพได้ง่ายนัก
แต่ด้วยการคำนวณหาระยะห่างระหว่างจุดสองจุดด้วยกฏของยูคลิดนั้น สามารถทำได้แม้ว่าจะมีมิติหรือมีฟีทเจอร์เพิ่มขึ้น หลายฟีทเจอร์ก็ตาม
จากเดิมมีเพียงสองมิติคือ x และ y เมื่อจุด a(x1, y1) และ b(x2, y2)
หากมีมิติหรือฟีทเจอร์เพิ่มขึ้นเป็นจำนวน n ก็ยังสามารถคำนวณได้ดังนี้
เมื่อจุด a(x1, y1, ... , n1) และ b(x2, y2, …, n2)
คุณสามารถหารายละเอียดเรื่องนี้อ่านเพิ่มเติมได้จาก [a]
ต่อไปเรามาทดลองเขียนโค้ดโปรแกรมเพื่อทำการคำนวณหาระยะทางแบบยูคลิดกัน
เริ่มต้นด้วยการอ้างถึงไลบรารี่ของ scipy ซึึ่งเป็นไลบรารี่เพื่อใช้ในการคำนวณทางวิทยาศาสตร์ ซึ่งสามารถติดตั้งได้โดยตรงหรือผ่าน Anaconda ก็ได้เช่นเดียวกัน
ให้ทำการแก้ไขโค้ดโปรแกรม บรรทัดแรกดังนี้
จากนั้นให้เพิ่มโค้ดโปรแกรมดังนี้
โดยที่
def euc(a, b) :
โดย a และ b คือพารามิเตอร์ ตำแหน่งของจุดในข้อมูลสำหรับการทดสอบ (testing data)
และฟังก์ชั่นต่อไปนี้
return distance.euclidean(a, b)
ทำหน้าที่คืนค่าผลลัพท์เป็นระยะความห่างของจุด a และ b
ขั้นตอนที่ 7 นำอัลกอริธึมการเทียบเคียงกับจุดใกล้เคียงมาใช้ (Nearest Neighbor)
ในขั้นตอนนี้เราจะกลับมาพิจารณาอัลกอริธึมเพื่อการแยกแยะข้อมูลอีกครั้ง
เพื่อการทำนายจุดทดสอบ เราจำเป็นต้องคำนวณหาระยะความห่างระหว่างจุดทดสอบ (testing point) ไปยังจุดสอน (training points) ทุกๆ จุด จากนั้นจึงทำการทำนายว่าจุดทดสอบนั้นควรเป็นข้อมูลประเภทใด และเปรียบเทียบผลลัพท์ที่ได้ว่าถูกต้องหรือไม่
เราจะทำการลบ การทำนายแบบสุ่ม ที่เราเขียนไว้ก่อนหน้า และเปลี่ยนเป็นเมทธอดที่ทำหน้าที่ค้นหาจุดสอนที่อยู่ใกล้กับจุดทดสอบมากที่สุด
ในบทเรียนนี้เราเขียนโค้ดโปรแกรมกำหนดค่าคงที่ให้กับ k ไว้เท่ากับ 1
ดังนั้นเมื่อเราเขียนโค้ดโปรแกรมเพื่อการแยกแยะข้อมูลด้วยวิธีการเทียบเคียงกับจุดใกล้เคียง
(nearest neighbor classifier)
อย่างไรก็ตาม ตัวแปร k ไม่ได้ปรากฏอยู่ในโค้ดโปรแกรมนี้
เนื่องจากเราต้องหาจุดที่อยู่ใกล้เคียงมากที่สุดเท่านั้น
ในเมทธอดนี้ เราทำการโปรแกรมให้เกิดการทำงานแบบวนรอบ เพื่อหาระยะห่างระหว่างจุดทดสอบกับจุดสอนทุกๆ จุด และทำการบันทึกจุดที่ใกล้เคียงที่สุดไว้เพียงจุดเดียวเท่านั้น
แน่นอนเราต้องใช้ฟังก์ชั่น fit และ x_train ที่ประกอบด้วยฟีทเจอร์ต่างๆ
จากนั้นเราจะเริ่มต้นทำการคำนวณระยะห่างจากจุดทดสอบ กับจุดสอน จุดแรก
โดยเราจะใช้ตัวแปร best_dist นี้เพื่อจดจำระยะทางที่สั้นที่สุดไว้เท่านั้น
และใช้ตัวแปร best_index เพื่อบันทึกติดตามดัชนี้ (index) ของจุดสอน ที่ใกล้ที่สุด
จากนั้นเราจะทำการวนรอบ (บรรทัดที่ 21) ตามจำนวนจุดสอนทั้งหมด โดยในแต่ละรอบจะทำการเปรียบเทียบค่าระยะความห่างของจุดสอนกับจุดทดสอบที่คำนวณได้ในแต่ละครั้งกับระยะความห่างจากที่คำนวณได้ในรอบก่อนหน้า และแทนที่ด้วยระยะที่สั้นกว่าเสมอ ลงในตัวแปร best_dist และ best_index
ในบรรทัดสุดท้าย (26) จะทำการคืนค่าผลลัพท์ที่ได้จากการคำนวณและประมวลผลในขั้นตอนนี้ ด้วยระยะทางของจุดสอนกับจุดทดสอบที่สั้นที่สุด และดัชนีของจุดสอน เพื่อระบุว่าเป็นจุดสอนใดนั่นเอง
ขั้นตอนที่ 8 การทำงานด้วยไปป์ไลน์
เมื่อถึงขั้นตอนนี้ เราได้มี เครื่องมือการแยกแยะข้อมูลด้วยวิธีเปรียบเทียบข้อมูลกับข้อมูลใกล้เคียง เรียบร้อยแล้ว ลำดับถัดไปเรามาทดลองการทำงานเครื่องมือที่เราได้สร้างขื้นเพื่อดูว่าให้ผลลัพท์ด้วยอัตราความถูกต้องแม่นยำเพียงไร
หลังจากสั่งให้โปรแกรมทำงานแล้ว พบว่าผลลัพท์ที่ได้มีอัตราความถูกต้องที่ 0.986666667 หรือ 98.66% ซึ่งมากกว่า 90% อย่างไรก็ตามหากคุณสั่งให้โปรแกรมทำงานในคอมพิวเตอร์ของคุณอาจได้ผลลัพท์ที่แตกต่างไปจากนี้เนื่องจากการสุ่มใช้ข้อมูลสอนที่แตกต่างกัน
หากคุณสามารถเขียนโค้ดโปรแกรมเสร็จสิ้นและทำงานได้แล้ว รวมทั้งสามารถเข้าใจการทำงานของโค้ดโปรแกรมเป็นอย่างดีแล้วนั่นหมายความว่าคุณสามารถเขียนโค้ดโปรแกรมหรือเครื่องมือเพื่อทำการแยกแยะข้อมูลแบบง่ายๆ เพื่อแก้ไขปัญหาได้แล้ว อย่างไรก็ตามยังคงมีข้อดีและข้อเสีย ของอัลกิริธึมหรือขั้นตอนวิธีนี้กล่าวคือ
ข้อดี
- ค่อนข้างเข้าใจได้ง่าย (Relatively simple) และทำงานได้ดีเหมาะกับงานบางอย่าง
ข้อด้วย
- ทำงานช้า เนื่องจากต้องวนรอบคำนวณในการหาระยะความห่างระหว่างจุดทดสอบกับจุดที่ใช้สอนทุกจุด (Computationally intensive) เพื่อใช้ในการทำนายผล
- จากที่เราพบในบทเรียนที่ 3 ซึ่งฟีทเจอร์บางอันมีข้อมูลที่ซับซ้อนกว่าฟีทเจอร์อื่นๆ จึงยากที่จะนำเสนอความสัมพันธ์ระหว่างฟีทเจอร์ให้เข้าใจได้ง่าย (Hard to represent relationships between features) ในแบบ k-Nearest Neighbors
ในการทำงานระยะยาวแล้ว เราต้องการเครื่องมือในการแยกแยะ ที่สามารถเรียนรู้ความสัมพันธ์ที่สลับซับซ้อนของฟีทเจอร์ได้ และ เลเบลหรือระบุผลลัพท์ที่เราพยายามทำนาย
ด้วยต้นไม้ตัดสินใจเป็นตัวอย่างที่ดี รวมทั้งเครือข่ายประสาทเทียม ที่เราเห็นในพื้นที่ทดลองของเท็นเซอร์โฟลว ก็เป็นตัวอย่างที่ดีเช่นเดียวกัน
อย่างไรก็ตามหวังว่าความรู้ที่ได้จากบทเรียนนี้จะเป็นประโยชน์บ้างไม่มากก็น้อย แล้วพบกันใหม่ในบทเรียนถัดไป
โดย ผศ. ณัฏฐ์ โอธนาทรัพย์
สาขาวิชาวิศวกรรมคอมพิวเตอร์ คณะวิศวกรรมศาสตร์ มหาวิทยาลัยเอเชียอาคเนย์
By Asst., Prof. Nuth OTANASAP
Department of Computer Engineering, Faculty of Engineering,
Southeast Asia University, Bangkok 10160 THA
ไม่มีความคิดเห็น:
แสดงความคิดเห็น