Make your own Neural Network #2

จากตอนที่ 1 ซึ่งทำให้เห็นถึงแนวคิดพื้นฐานของ Neural Network ซึ่งจะเน้นไปที่การทำนาย (Prediction) ตอนที่ 2 จะกล่าวถึงอีกฟังก์ชันหนึ่งของ Neural Network ซึ่งก็คือ การจัดกลุ่ม (Classifying)

บทความนี้เรียบเรียงจากหนังสือ ชื่อ Make your own Neural Network

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

คราวนี้เราจะลองข้อมูลอีกประเภทหนึ่ง ซึ่งเป็นข้อมูลของแมลงในสวน โดยมี 2 ประเภท คือ หนอนผีเสื้อ (caterpillar) และ เต่าทอง (ladybird) ซึ่งเมื่อวัดตามขนาดความกว้างและความยาว จะพล็อตเป็นกราฟได้ดังนี้

จากกราฟนี้ เราสามารถมองเห็นกลุ่มของแมลงสวนได้อย่างชัดเจน กลุ่มหนึ่งคือหนอนผีเสื้อ ซึ่งมีลักษณะผอมและยาว อีกกลุ่มหนึ่งคือด้วงเต่าทอง ซึ่งมีลักษณะกว้างและสั้น

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

จะเกิดอะไรขึ้นหากเราวางเส้นตรงเพื่อใช้แบ่งกลุ่มแมลงทั้ง 2 กลุ่ม

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

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

ลองเส้นแบ่งแยกใหม่ โดยปรับความชันอีกครั้ง และดูว่าเกิดอะไรขึ้น

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

ยอดเยี่ยม! เส้นแบ่งแยกใหม่นี้แยกหนอนผีเสื้อออกจากด้วงเต่าทองอย่างชัดเจน ตอนนี้เราสามารถใช้เส้นนี้เป็นตัวจัดประเภทแมลงได้แล้ว

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

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

ดูที่กราฟถัดไป คุณจะเห็นว่าแมลงที่ไม่รู้จักเป็นหนอนผีเสื้อเพราะมันอยู่เหนือเส้น แม้การจัดประเภทนี้จะเป็นแบบง่ายๆ แต่ก็น่าทึ่งมากแล้ว!

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

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

เราจะลองสร้าง Simple Classifier กัน

เราต้องการที่จะฝึกโมเดลตัวจำแนกเชิงเส้น (linear classifier) ของเรา ให้สามารถจำแนกประเภทของแมลงได้อย่างถูกต้องว่าเป็นเต่าทองหรือหนอนผีเสื้อ

การเทรนโมเดลนี้เป็นเพียงการปรับความชันของเส้นแบ่ง (dividing line) ที่แยกจุดสองกลุ่มออกจากกันบนพล็อตกราฟ โดยใช้ค่าความกว้างและความยาวของตัวแมลง

การทำงานนี้มีขั้นตอนอย่างไร

แทนที่จะไปพัฒนาสูตรคณิตศาสตร์ที่ซับซ้อน, ลองมา “สัมผัส” วิธีการนี้ด้วยการลงมือทำกันจริงๆ ดีกว่า เราจะเข้าใจหลักการทางคณิตศาสตร์ได้ดีขึ้น

แน่นอน เราต้องมีตัวอย่างให้เรียนรู้ด้วย ตารางต่อไปนี้แสดงตัวอย่างสองตัวอย่าง เพื่อให้เข้าใจง่าย

เรามีตัวอย่างแมลงที่มีความกว้าง 3.0 และความยาว 1.0 ซึ่งเรารู้ว่าเป็นเต่าทอง

เรายังมีตัวอย่างแมลงอีกตัวหนึ่งที่ยาวกว่าที่ 3.0 และบางกว่าที่ 1.0 ซึ่งเป็นหนอนผีเสื้อ

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

มาเริ่มด้วยเส้นแบ่งแบบสุ่มสักเส้นหนึ่งก่อน เพื่อเริ่มต้นจากจุดไหนสักแห่ง

เมื่อมองย้อนกลับไปที่โมเดลทำนายไมล์เป็นกิโลเมตรของเรา เรามีฟังก์ชันเชิงเส้น (linear function) ซึ่งเราได้ปรับค่าพารามิเตอร์ของมัน เราสามารถทำการแบบเดียวกันนี้ได้ที่นี่ เพราะเส้นแบ่งที่เราต้องการก็คือเส้นตรงเช่นกัน

กำหนดให้ y = Ax

เราใช้ชื่อตัวแปร Y และ X แทนความยาวและความกว้าง เพราะเส้นแบ่งในนี้ไม่ใช่โมเดลการทำนาย เพราะไม่ใช่การแปลงความกว้างเป็นความยาว เหมือนกับที่เราแปลงไมล์เป็นกิโลเมตรก่อนหน้านี้

แต่เป็นเส้นแบ่งประเภท ตัวแบ่งชนิดแมลง

คุณอาจจะสังเกตเห็นว่าสมการ y = Ax นี้ง่ายกว่ารูปแบบเต็มของเส้นตรง y = Ax + B

เราจงใจทำให้สถานการณ์สวนแมลงนี้ง่ายที่สุดเท่าที่จะเป็นไปได้

การมี B ที่ไม่เป็นศูนย์ มีหมายความว่า เส้นแบ่งนี้ไม่ผ่านจุดกำเนิดของกราฟ ซึ่งไม่เพิ่มประโยชน์อะไรในสถานการณ์ของเรา ดังนั้นเราจึงกำหนดให้ B เป็น 0 ทำให้คงเหลือเพียงสมการ y = Ax

เรารู้ว่าพารามิเตอร์ A ควบคุมความชันของเส้น ยิ่ง A มาก ยิ่งความชันมาก

เพื่อเริ่มต้น เราลองให้ A เป็น 0.25 เส้นแบ่งจะกลายเป็น y = 0.25x

มาพล็อตเส้นนี้บนกราฟเดียวกันกับข้อมูลการฝึกอบรมเพื่อดูว่ามันเป็นอย่างไร:

เห็นได้ชัดว่าเส้น y = 0.25x นี้ไม่ใช่ตัวจำแนกประเภทที่ดีตั้งแต่แรก โดยไม่ต้องทำการคำนวณใดๆ เพื่อพิสูจน์

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

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

ลองดูตัวอย่างการฝึกแรก: ความกว้างคือ 3.0 และความยาวคือ 1.0 สำหรับเต่าทอง ถ้าเราทดสอบฟังก์ชัน y = Ax กับตัวอย่างนี้โดยที่ x เป็น 3.0 เราจะได้ผลลัพธ์เป็น…

y = (0.25) * (3.0) = 0.75

ฟังก์ชันนี้ซึ่งมีพารามิเตอร์ A ตั้งค่าเป็นค่าเริ่มต้นที่เลือกแบบสุ่มเป็น 0.25 แนะนำว่าสำหรับแมลงที่มีความกว้าง 3.0 ความยาวควรเป็น 0.75 แสดงให้เห็นว่าค่าที่คำนวณออกมาได้น้อยเกินไป เพราะตัวอย่างข้อมูลการฝึกอบรมบอกเราว่าต้องมีความยาว 1.0

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

แต่ก่อนที่เราจะทำการปรับค่า เราจะคิดว่า y ควรจะเป็นค่าใดอีกซักครั้ง หาก y เป็น 1.0 เส้นจะผ่านจุดที่เต่าทองอยู่ที่ (x,y) = (3.0, 1.0) แม้ว่าจะเป็นเส้นที่ใช้ได้ แต่เส้นแบ่งไม่ควรผ่านจุดนั้นพอดี เราอยากให้เส้นอยู่เหนือจุดนั้นเล็กน้อย ทำไม? เพราะเราต้องการให้จุดของเต่าทองทั้งหมดอยู่ใต้เส้น ไม่ใช่อยู่บนเส้น เส้นจำเป็นต้องเป็นเส้นแบ่งระหว่างเต่าทองและหนอนผีเสื้อ ไม่ใช่ตัวทำนายความยาวของแมลงตามความกว้างของมัน

ดังนั้น ลองตั้งเป้าหมายให้ y = 1.1 เมื่อ x = 3.0 ซึ่งเป็นจุดที่อยู่เหนือ 1.0 เล็กน้อย เราอาจเลือก 1.2 หรือแม้แต่ 1.3 ก็ได้ แต่เราไม่ต้องการตัวเลขที่ใหญ่กว่า เช่น 10 หรือ 100 เพราะจะทำให้เส้นมีแนวโน้มที่จะอยู่เหนือทั้งเต่าทองและหนอนผีเสื้อ ส่งผลให้เกิดตัวแบ่งที่ไร้ประโยชน์

ในกรณีที่เราเลือกค่า y เป็น 1.1 ค่าของ error E คือ

error = (desired target - actual output) = 1.1 - 0.75 = 0.35

ตอนนี้ คำถามสำคัญคือ เราจะใช้ Error นี้ เพื่อปรับแต่งพารามิเตอร์ A ให้ดีขึ้นได้อย่างไร?

ก่อนอื่น ลองถอยกลับมาสักก้าว เราต้องการใช้ E ซึ่งเป็นข้อผิดพลาดในผลลัพธ์ y เพื่อบอกการเปลี่ยนแปลงที่จำเป็นสำหรับพารามิเตอร์ A แต่เพื่อทำเช่นนั้น เราจะต้องรู้ความสัมพันธ์ระหว่างทั้งสอง ว่า A เกี่ยวข้องกับ E อย่างไร? ถ้าเราเข้าใจความสัมพันธ์นี้ เราจะเข้าใจว่าการเปลี่ยนแปลงตัวใด ส่งผลต่ออีกตัวอย่างไร

เราจะเริ่มด้วย linear function

y = Ax

เรารู้ว่าสำหรับค่า A ที่เดาครั้งแรก จะให้คำตอบวาย (y) ที่ผิด เรียกค่าเป้าหมายที่ต้องการที่ถูกต้องว่า t เพื่อให้ได้ค่าที t นั้น เราจำเป็นต้องปรับเอ (A) ทีละน้อย นักคณิตศาสตร์ใช้สัญลักษณ์เดลต้า (Δ) เพื่อหมายถึง “การเปลี่ยนแปลงเล็กน้อย” เขียนออกมาได้ดังนี้:

t = (A + ΔA)x

รูปภาพข้างล่างนี้จะทำให้เข้าใจได้ง่ายขึ้น ในรูปจะเห็นเส้นความชันใหม่ ( A + Δ A ) ที่เกิดจากการปรับ ΔA

จำไว้ว่าค่า E คือค่าความคลาดเคลื่อน (error) ซึ่งเป็นผลต่างระหว่างค่าที่ถูกต้องที่เราต้องการ กับค่าที่เราคำนวณได้จากการคาดเดาปัจจุบันของค่า A ดังนั้น E จึงเท่ากับ t-y

โดยสามารถเขียนให้ชัดเจนมากขึ้นดังนี้

t - y = (A + ΔA)x - Ax

เมื่อทำการขยาย Term หรือ ทำให้อยู่ในรูปอย่างง่าย จะได้ว่า

E = t — y = Ax + (ΔA)x - Ax

E = (ΔA)x

น่าทึ่งมาก! ความสัมพันธ์ระหว่างความคลาดเคลื่อน E กับ ΔA นั้นง่ายมากจนฉันคิดว่ามันต้องผิดแน่ๆ แต่ปรากฏว่ามันถูกจริงๆ อย่างไรก็ตาม ความสัมพันธ์ง่ายๆ นี้ทำให้ชีวิตเราเบาลงมาก

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

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

ΔA = E / x

ใช่แล้ว! นี่คือนิพจน์มหัศจรรย์ที่เรากำลังมองหา เราสามารถใช้ความคลาดเคลื่อน E เพื่อปรับแต่งความชัน A ของเส้นแบ่งประเภทด้วยจำนวน ΔA

มาเริ่มกันเลยดีกว่า — ปรับความชันจากความชันเดิม

ความคลาดเคลื่อน E คือ 0.35 และค่า x คือ 3.0 นั่นทำให้เราได้ ΔA = E / x ซึ่งเท่ากับ 0.35 / 3.0 = 0.1167 หมายความว่าเราต้องเปลี่ยนค่า A เดิมที่เท่ากับ 0.25 ไป 0.1167 ดังนั้น ค่า A ใหม่ที่ปรับปรุงแล้วจึงเป็น (A + ΔA) ซึ่งเท่ากับ 0.25 + 0.1167 = 0.3667 บังเอิญว่าค่า y ที่คำนวณด้วย A ใหม่นี้เท่ากับ 1.1 ซึ่งก็เป็นไปตามคาดเพราะเป็นค่าเป้าหมายที่ต้องการ

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

เรามาทำกันต่อไป

ตอนนี้ ผ่านไปหนึ่งตัวอย่างของการ Train แล้ว มาดูตัวอย่างต่อไปกันดีกว่า คราวนี้เรามีค่าจริง คู่ของ x = 1.0 และ y = 3.0

แปลข้อความเป็นภาษาไทย:

มาดูกันว่าจะเกิดอะไรขึ้นเมื่อเราใส่ x = 1.0 ลงในฟังก์ชันเชิงเส้นซึ่งตอนนี้ใช้ A ที่ได้ปรับปรุงแล้ว ซึ่งก็คือ A = 0.3667 เราจะได้ผลลัพธ์ y = 0.3667 * 1.0 = 0.3667 แต่นั่นไม่ใกล้เคียงเลยกับตัวอย่างการ Train ที่มี y = 3.0

โดยใช้เหตุผลเดียวกับก่อนหน้านี้ว่า เราต้องการให้เส้นไม่ตัดผ่านข้อมูลการฝึกอบรม แต่อยู่เหนือหรือใต้ข้อมูลเล็กน้อย ดังนั้นเราจึงกำหนดค่าเป้าหมายไว้ที่ 2.9 ด้วยวิธีนี้ ตัวอย่างฝึกอบรมของหนอนผีเสื้อจะอยู่เหนือเส้น แต่ไม่อยู่บนเส้นพอดี ค่าความคลาดเคลื่อน E เป็น (2.9–0.3667) = 2.5333

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

มาอัปเดตค่า A กันอีกครั้ง เหมือนกับที่เราทำไปก่อนหน้านี้ ค่า ΔA คือ E / x เท่ากับ 2.5333 / 1.0 = 2.5333 นั่นหมายความว่าค่า A ใหม่ล่าสุด คือ 0.3667 + 2.5333 = 2.9 หมายความว่าสำหรับ x = 1.0 ฟังก์ชันจะให้คำตอบเป็น 2.9 ซึ่งเท่ากับค่าเป้าหมายที่ต้องการพอดี

โอเค! เราจะหยุดซักหน่อยพักและดูว่าเราทำอะไรไปแล้วบ้างในแบบรูปภาพ ภาพต่อไปนี้แสดงเส้นเริ่มต้น เส้นที่ปรับปรุงหลังจากเรียนรู้จากตัวอย่างฝึกอบรมแรก และเส้นสุดท้ายหลังจากเรียนรู้จากตัวอย่างฝึกอบรมที่สอง

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

มันก็ได้อย่างที่เราทำ เส้นปรับตัวเองเพื่อให้ได้ค่า y ตามที่ต้องการสำหรับแต่ละตัวอย่าง เมื่อเรามีแค่ 2 ตัวอย่าง จึงได้เส้นที่ปรับสำหรับแต่ละตัวอย่าง

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

แล้วเราจะแก้ไขอย่างไร?

ง่ายๆ เลย! และนี่เป็นแนวคิดสำคัญในด้าน machine learning เราจะ “ลดทอนการอัปเดต” นั่นคือแทนที่จะกระโดดไปหาค่า A ใหม่ทันทีด้วยความตื่นเต้น เราจะใช้เพียงส่วนหนึ่งของการเปลี่ยนแปลง ΔA ไม่ใช่ทั้งหมด วิธีนี้เราจะมุ่งไปในทิศทางที่ตัวอย่างการฝึกอบรมชี้แนะ แต่ทำอย่างระมัดระวัง โดยเก็บรักษาบางส่วนของค่าเดิมไว้ ซึ่งอาจมาจากการเรียนรู้จากตัวอย่างการฝึกอบรมมากมาย

เราเคยเห็นแนวคิดการลดทอนการปรับแต่งนี้มาก่อนกับตัวทำนายไมล์-กิโลเมตรที่ง่ายกว่า ซึ่งเราค่อยๆ ปรับพารามิเตอร์ c เพียงเศษหนึ่งของความคลาดเคลื่อนจริง

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

โอเค! งั้นมาทำกันใหม่ แค่เราจะเพิ่มการลดทอนการอัปเดต ซึ่งจะได้สมการเป็น

ΔA = L (E / x )

ปัจจัยที่ใช้ในการลดทอนการอัปเดตมักเรียกว่า “อัตราการเรียนรู้” (learning rate) และเราเรียกมันว่า L ในที่นี้เราจะเลือก L = 0.5 เป็นเศษส่วนที่พอเหมาะเพื่อเริ่มต้น หมายความว่าเราจะอัปเดตเพียงครึ่งหนึ่งเมื่อเทียบกับการอัปเดตแบบเต็มรูปแบบที่ไม่มีปัจจัยการลดทอน

มาดูตัวอย่างการอัปเดตโดยใช้ learning rate กันอีกครั้ง:

1. เริ่มต้นด้วยค่า A เริ่มต้น = 0.25
2. ตัวอย่างการฝึกอบรมแรกให้ค่า y = 0.25 * 3.0 = 0.75
3. ค่าเป้าหมายที่ต้องการคือ 1.1 ดังนั้นความคลาดเคลื่อนคือ 0.35 (1.1–0.75)
4. ΔA = L (E / x) = 0.5 * 0.35 / 3.0 = 0.0583 (ใช้ learning rate L เพื่อลดทอน ΔA)
5. ค่า A ที่อัปเดตใหม่คือ 0.25 + 0.0583 = 0.3083

สังเกตว่าการใช้ learning rate 0.5 ทำให้การอัปเดตค่า A ลดลงจาก 0.1167 (ในกรณีที่ไม่มีการลดทอน) เหลือเพียง 0.0583 เพื่อให้การเรียนรู้เป็นไปอย่างค่อยเป็นค่อยไปและลดผลกระทบจากความคลาดเคลื่อนในข้อมูล

เมื่อลองใช้ค่า A ใหม่ที่อัปเดตแล้วกับตัวอย่างการฝึกอบรมที่ x = 3.0 จะได้ค่า y = 0.3083 * 3.0 = 0.9250 ตอนนี้เส้นอยู่ใต้จุดข้อมูลตัวอย่างแรกเพราะค่า y น้อยกว่า 1.1 แต่มันก็ไม่ใช่ผลลัพธ์ที่แย่นัก ถ้าพิจารณาว่ามันเป็นเพียงการอัปเดตแรกในอีกหลายๆ ครั้งที่จะเกิดขึ้น อย่างน้อยเส้นก็ขยับไปในทิศทางที่ถูกต้องจากเส้นเริ่มต้น

มาต่อกันที่ตัวอย่างการฝึกอบรมที่สองที่ x = 1.0 ใช้ค่า

1. A = 0.3083

2. จะได้ค่า y = 0.3083 * 1.0 = 0.3083

3. ค่าเป้าหมายที่ต้องการคือ 2.9 ดังนั้นความคลาดเคลื่อนคือ (2.9–0.3083) = 2.5917

4. ΔA = L (E / x) = 0.5 * 2.5917 / 1.0 = 1.2958

5. ค่า A ที่อัปเดตใหม่อีกครั้งคือ 0.3083 + 1.2958 = 1.6042

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

ยอดเยี่ยมมาก!

แม้ว่าเราจะมีตัวอย่างการฝึกอบรมเพียงสองตัวอย่างและใช้วิธีการปรับปรุงพารามิเตอร์แบบง่าย โดยใช้ learning rate เพื่อลดทอนการอัปเดต แต่เราก็สามารถหาเส้นแบ่งประเภท y = Ax ที่แม่นยำได้อย่างรวดเร็ว โดยที่ A มีค่าเท่ากับ 1.6042

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