AlphaGo : Part I คอมพิวเตอร์เรียนรู้ด้วยตัวเองได้อย่างไร ?
เนื้อหาของบทความนี้เป็นเนื้อหาที่แยกย่อยมาจากเนื้อหาหลักอีกทีหนึ่ง คุณสามารถอ่านบทความเต็มได้ที่นี่ http://blog.kosatestudio.com/2016/03/12/how-alphago-work/
Part I : Introduction
Searching
จินตนาการว่าเราเล่นเกมกระดานอะไรสักอย่าง อาจจะเป็นหมากรุกหรือหมากฮอสก็ได้นะครับ พอคุณเล่นเกมไปจนถึงกลางเกมแล้ว จะมีช่วงดุเดือดคือช่วงที่มีการกินกันไปสลับกันมาระหว่างคุณและศัตรูวิธีที่ปลอดภัยสุดที่ทำให้คุณเล่นเกมจนชนะได้นั้นคือ คุณต้องจินตนาการว่าอนาคตนั้นศัตรูจะลงเดินหมากแบบไหน คุณอาจจะคิดข้ามมากสุดได้ประมาณ 2-3 สเต็ป
ไอ้วิธีการแบบนี้ วิธีที่การที่เราคิดล่วงหน้าไปหลายๆสเต็ปเพื่อดักทางศัตรูเนี่ย ในทางคอมพิวเตอร์แล้วการคิดจำนวนวิธีล่วงหน้านั้นเรียกว่า Searching ครับ
คอมพิวเตอร์จะทำการค้นหารูปแบบของเกมที่เป็นไปได้ในอนาคตหลายขั้นหน่อย เพื่อเลือกวิธีที่ดีที่สุดในการเดินหมาก ซึ่งคุณอาจจะให้คอมพิวเตอร์ทำงานโดยการคำนวณทุกกรณีที่เป็นไปในอนาคต แต่ ว่า… สำหรับเกม Go แล้ว คุณไม่สามารถ Search หาทุกกรณีที่เป็นไปได้ครับ
เราคิดทุกกรณีของคู่ต่อสู้ไม่ได้หรือ (Brute Force) ?
หลายคนอาจตั้งคำถามว่าทำไมไม่จำลองวิธีการเดินในอนาคตของศัตรูทุกวิธีที่ เป็นไปได้ แล้วหาหมากที่ดีที่สุดที่ทำให้เราได้เปรียบบนทุกความเป็นไปได้ในอนาคตไม่ดี กว่าหรือ (วิธีการแบบนี้ในทางคอมพิวเตอร์เรียกว่า Brute Force)ผมคำนวณคร่าวๆนะ กระดานโกะมีเส้นแนวตั้ง 19 เส้น แนวนอน 19 เส้น จุดตัดที่ได้ทั้งหมดเท่ากับ 361 จุด และจำนวนวิธีในการวางหมากที่เป็นไปได้นั้นคือ…
208168199381979984699478633344862770286522453884530548425639456820927419612738015378525648451698519643907259916015628128546089888314427129715319317557736620397247064840935
ตัวเลขอ้างอิงจาก Number of legal Go positions
ซึ่งมันมีจำนวนมากกว่าจำนวนอะตอมในจักรวาลรวมกันซะอีก
เพราะฉะนั้นสิ่งที่คอมพิวเตอร์พอทำได้ตอนนี้คือ หาความเป็นไปได้ที่ดีมากพอ จนทำให้ไม่ต้องประมวลทุกความเป็นไปได้ที่อาจทำให้เสียเวลามหาศาล
ดังนั้นเราจึงต้องแก้ปัญหาด้วยวิธีอื่นครับ
Machine Learning
ลองจินตนาการดูนะครับ จินตนาการว่าคุณเป็นเด็กตัวน้อยคนหนึ่ง คุณเห็นวัตถุประหลาดไม่รู้ว่ากินได้หรือเปล่า คุณหยิบวัตถุนั้นมาพิจารณาอย่างลังเล มันมีสีแดง คุณกินเข้าไปปรากฏว่า “อร่อยแฮะ” คุณก็จะจดจำว่าวัตถุสีแดง มันอร่อยแต่แล้ววันหนึ่งคุณก็เห็นวัตถุสีเขียว คุณกินมันเข้าไป “รสชาติห่วยแตกมากก” คุณก็จะจดจำว่าวัตถุสีเขียว ไม่ควรกิน
เช่นเดียวกันกับบอท AlphaGo ครับ AlphaGo ก็เรียนรู้ว่า การเดินหมากแบบนี้มันถูกต้องนะ การเดินหมากแบบนี้มันไม่ถูกนะ ซึ่งคำว่าถูกไม่ถูกเนี่ยมันค่อนข้างจะกำกวมไปสักเล็กน้อย แต่จริงๆแล้วกระบวนการคิดของ AlphaGo เนี่ย อยู่บนพื้นฐานของคณิตศาสตร์ที่มีเล็กเกือบ 1 พันล้านเลขประมวลผลพร้อมกันในเวลา 1 วินาที
คำถามคือ : มันเรียนรู้อย่างไร ?
Machine Learning คือ วิธีการที่ใช้ในการแก้ปัญหานี้ครับ ซึ่งดูแล้วจะเป็นคำที่กว้างๆหน่อย สำหรับคนที่ศึกษามาด้านนี้อยู่แล้ว แต่มันเป็นคำศัพท์ที่แปลกประหลาดมากสำหรับคนที่ไม่เคยรู้อะไรก่อนเกี่ยวกับ คอม
แต่ถ้าจะให้ผมอธิบายรายละเอียดปลีกย่อยหมด คุณคงไม่ได้อ่าน AlphaGo ก่อนจบวันเพราะเสียเวลาอ่าน Machine Learning ทั้งวัน เพราะฉะนั้นเนื้อหาที่ผมจะพูดต่อไปเนี่ย ผ่านการลดทอนแล้วลดทอนอีก ถ้าหากใครงงเนี่ย ก็ไม่ต้องแปลกใจนะครับ 5555
Machine Leaning เป็นศาสตร์อย่างหนึ่งของคอมพิวเตอร์นะครับ ซึ่งเขาไม่ได้เพิ่งคิดค้นกันมาได้เมื่อเร็วๆนี้ แต่คิดค้นมาตั้งนานแล้ว เป็นกระบวนการที่ให้โปรแกรมเรียนรู้สิ่งๆหนึ่ง แต่คำถามมันเรียนรู้อย่างไร ก่อนอื่นผมจะพูดศัพท์แปลกๆที่เรียกว่า Input กับ Output ก่อนละกัน
Input เป็น ข้อมูลอย่างหนึ่งที่ป้อนให้โปรแกรมสำหรับทำงาน ส่วน Output เป็นข้อมูลอย่างหนึ่งที่โปรแกรมให้ผลลัพธ์ตอบกลับมา เช่นเดียวกับเกม Go เราจะมี Input คือกระดานทั้งกระดาน และ Output คือตำแหน่งของหมากที่เราจะวางลงไป
ซึ่ง Input ที่เป็นกระดานเนี่ย เวลาคอมพิวเตอร์เอาไปคิด มันไม่ได้คิดเป็นรูปภาพครับ แต่มันมองเป็นตัวเลขและพิกัด เราอาจจะแทนพิกัด (x,y) สำหรับบอกว่าหมากสีดำอยู่พิกัดไหนบ้าง และหมากสีขาวอยู่พิกัดไหนบ้าง และ Output ออกมาเป็นเป็นพิกัด (x,y) เช่นกัน
ประเด็นมันอยู่ตรงนี้ครับ มันเอาพิกัด (x,y) ต่างๆเนี่ย ผ่านเข้าไปในโปรแกรม ทำการคำนวณ วิเคราะห์ แยกแยะ แบ่งแยก ปรับเปลี่ยน ทำทุกอย่างโดยมีกระบวนมาจากสิ่งที่เป็น “บวก ลบ คูณ หาร” ทั้งหมด ใช่ครับ ทุกอย่างเป็นคณิตศาสตร์
เอาล่ะ… มาถึงจุดนี้คงจะเห็นผมพ่นสมการอะไรแปลกๆออกมาใช่ไหมครับ ผมการันตีได้ว่าถ้าคุณเห็นสมการคณิตศาสตร์เมื่อไหร่หลังจากอ่านประโยคนี้จบ คุณปิดได้เลยครับ 5555
Neural Network
อะไรคือ Neural Network ? Neural Network เป็นเรื่องนี้เป็นเรื่องแยกย่อยออกมาจาก Machine Learning นะครับ แต่ถึงจะแยกย่อยมาจาก Machine Learning แล้ว มันก็ยังเป็นหัวข้อที่ใหญ่ (มากๆ) อยู่ดีครับNeural Network นั้นเป็นหัวใจหลักของการแก้เกม Go เลยทีเดียวครับ Neural Network เป็นกระบวนการทางคอมพิวเตอร์ที่อิงมาจากหลักชีววิทยาพื้นฐาน สิ่งที่อ้างอิงก็ไม่ใช่อะไรก็มาจากสมองเรานี่แหละครับ สมองเรานั้นประกอบด้วยเซลล์หลายล้านเซลล์ ซึ่งแต่ละเซลล์ก็จะส่งข้อมูลไปมาหากัน เซลล์แต่ละเซลล์เพราะรับข้อมูลมาก็จะทำหน้าที่แปลงข้อมูลนั้นเป็นอะไรสัก อย่าง ก่อนจะส่งไปให้อีกเซลล์
ซึ่ง Neural Network มีพื้นฐานมาจากเรื่องนี้ครับ (ต่อไปผมจะเขียนว่า NN) NN นั้นก็จะจำลองสมองเรานี้ละครับ มันจะจำลองไปจนถึงระดับเซลล์ แต่เป็นรูปของคณิตศาสตร์แทน หลักชีววิทยา คือสมมุติให้มีตัวเลขบางอย่างเข้ามาในเซลล์ แล้วเซลล์ก็จะมีสมการคณิตศาสตร์อยู่ข้างในเพื่อปรับเปลี่ยนเลขนั้นให้เป็น ค่าใหม่ แล้วส่งไปให้อีกเซลล์ ซึ่งในคอมพิวเตอร์แล้วเขาไม่เรียกเซลล์ครับ เขาเรียก Node
Node แต่ละ Node จะมีหน้าที่ในการทำงานของตัวเองไม่เหมือนกัน แต่จะทำงานเชิงลึกมากๆที่จะแปลงตัวเลขหนึ่งเป็นตัวเลขหนึ่ง ซึ่งตัวเลขนั้นไม่มีความหมายใดๆเลย แต่พอมาประกอบกันแล้วมันก็กลายเป็นตัวเลขที่มีคำหมายเข้ามา
By Glosser.ca – Own work, Derivative of File:Artificial neural network.svg, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=24913461
วงกลมแต่อันคือ Node และเส้นเชื่อมระหว่าง Node คือสายการเดินทางของข้อมูล ในแต่วงกลมก็จะมีหน้าที่แปลงข้อมูลของตัวเอง โดยชุดกลมๆสีแดงด้านซ้ายคือข้อมูลที่เป็น Input ทั้งหมด และด้านขวาสีเขียวคือข้อมูลที่เป็น Output ทั้งหมด
และก็จะมี Node บางกลุ่มที่อยู่ระหว่าง Input กับ Output ครับ ซึ่งเรามักจะเรียกว่า Hidden Node ครับ ไอ้ตัว Hidden Node นี่ละที่เป็นตัวฮีโร่สำคัญของ NN เลยครับ
เพราะว่า Node บน Hidden Layer (กลุ่มของ Hidden Node) เนี่ยมันจะรับข้อมูลมาจาก Input แล้วค่อยส่งข้อมูลไปยัง Output ใช่ไหมครับ แล้วระหว่างทางก็มี Hidden Node ขั้นไว้ ซึ่ง Hidden Node เปรียบเสมือนตัวปรับแต่งข้อมูลให้มีหน้าตาที่แปลกประหลาดออกไป ซึ่งการปรับแต่งในที่นี้มันอยู่บนพื้นฐานของคณิตศาสตร์
ใช่แล้วครับ Hidden Node นั้นจะประกอบด้วยสมการคณิตศาสตร์ 1 อัน ซึ่งสมการนั้นสามารถพ่นคำตอบที่อาจจะเป็นแค่เลข 0 หรือเลข 1 2 ตัว หรืออาจจะเป็นเลขทศนิยม หรืออาจจะเป็นเลขประหลาดๆมากมาย ซึ่ง Node แต่ละอันก็จะมีการทำงานที่แตกต่างกัน และประหลาดๆกันออกไป
แต่พอมารวมกันปึบ ณ ที่จุด Output มันกลับออกมาเป็นคำตอบสวยงามภายใต้เงื่อนไขของสมการต่างๆที่ Hidden Node ช่วยกันให้ข้อมูลประมวลถูกต้องตามที่ต้องการ
จะเห็นว่ามันจำลองการทำงานของสมองได้ใกล้เคียงมาก เพียงแต่ข้อมูลที่เดินทางไปมาในสมองนั้นไม่ใช่ตัวเลข แต่สำหรับ NN แล้วมันเป็นการส่งข้อมูลแบบตัวเลข
แต่… แต่… แต่….
ต่อให้ผมเป็นโปรแกรมเมอร์ที่เทพขนาดไหน จุดเริ่มต้นของการเขียน NN นั้น คนเขียนไม่รู้หรอกครับว่า Node แต่ละ Node มันต้องทำงานอย่างไรบ้าง แล้วต้องใช้ Node เยอะมากขนาดไหนในการประมวลผลเกมที่ซับซ้อนขนาดนี้ ซึ่งถ้าใครสามารถวิเคราะห์โครงสร้างของ NN แล้วตีโจทย์เขียนออกมาได้เนี่ย ผมว่ามันคงเป็นยุคที่โลกเราเดินทางบนอวกาศเล่นกันแล้วละครับ
เอ้า แล้วถ้าเราเขียน NN ที่ทำงานแบบถูกต้องตามเงื่อนไขของ Input กับ Output ไม่ได้แล้ว เราจะเขียนยังไงละ ถ้าอย่างนั้น… ก็ทำแบบนี้ละกัน
เราก็เขียน NN และก็สร้าง Node มาจำนวนหนึ่ง โดยไม่สนใจว่า Node แต่ละ Node ทำงานอย่างไร แค่ติดตั้งการทำงานบางอย่างลงไปใน Node แต่ละ Node พอ ซึ่งการทำงานบน Node แต่ละอันอาจจะเป็นสมการคณิตศาสตร์แบบสุ่มๆ ซึ่งแน่นอนครับ..
การเขียน NN แบบนี้ มันทำให้โปรแกรมทำงานมั่วมากครับ ผิดมหันต์อย่างรุนแรง สมมุติว่าเราต้องการ Output ให้ออกมาเป็น 1 แต่ตอนเราเขียนมันมา Output อาจจะออกมาเป็น 1 ล้านก็ได้ ซึ่งข้อมูลมันมั่วสุดๆ Output ที่ออกมานั้นกลายเป็นอะไรก็ไม่รู้
แต่… แต่… แต่… จำที่ผมพูดถึงเด็กน้อยและวัตถุสีแดง สีเขียวได้ไหมครับ Input ของเราในที่นี้คือสี รูปร่างหรือลักษณะของวัตถุ ส่วน Output ก็ตอบสั้นๆว่าควรกิน หรือไม่ควรกิน แต่สำหรับการเขียน NN ที่สุ่มการทำงานของ Node นั้น คุณอาจจะได้ Output ออกมาเป็น “ไม่ควรกิน” กรณีได้ Input เป็น “สีแดง รูปร่างเป็นแอปเปิ้ล”
เพราะฉะนั้นมันถึงเวลาละครับ ถึงเวลาที่เราจะต้องทำให้ Node แต่ละ Node ต้องเรียนรู้ละว่า “สีแดง” ควรกินและ “สีเขียว” ไม่ควรกิน
Supervised Learning
สมมุติมีคนอยู่ 10 คน แต่ละคนต่างโยนข้อมูลมาให้คุณ คนที่ 1 อาจจะบอกว่า “สีแดง” กินได้ คนที่ 2 บอกว่า “สีแดงอมชมพู” กินได้ คนที่ 3 บอกว่า “สีเขียว” กินไม่ได้นะ ไปเรื่อยๆจนครบทุกคนคุณก็จะเรียนรู้ว่า “สีแดง” กินได้ ส่วน “สีเขียว” กินไม่ได้
คอมพิวเตอร์ก็ใช้หลักการนี้ในการเรียนรู้เหมือนกัน คำถามคือทำอย่างไรละ ?
Supervised Learning เป็นกระบวนการที่ให้คอมพิวเตอร์เรียนรู้จาก Input กับ Output ที่เตรียมไว้ให้แล้ว โดยคอมพิวเตอร์จะเรียนผ่านตัวอย่างที่มีมาให้ ผมจะขอเรียกข้อมูลตัวอย่างว่า Sample ละกัน
ยิ่ง Sample มากเท่าไหร่ การเรียนรู้ก็จะยิ่งถูกต้องมากขึ้นเท่านั้น ซึ่งหลักการทำงานของ Supervised Learning ก็อยู่บนพื้นฐานของ Sample
ตอนแรก NN ที่สร้างมานั้น โปรแกรมมันทำงานผิดพลาดมั่วซั่วหมดเลยใช่ครับ ดังนั้นเราจะต้องแก้ให้มันถูก คำถามคือแก้ยังไงละ ?
อันดับแรกครับเราต้องเปรียบเทียบการทำงานของโปรแกรมกับข้อมูลตัว Sample ก่อน ซึ่งถ้าหากข้อมูลที่ประมวลมาไม่ตรงกับ Sample นั้น ก็ให้ทำการแก้ไขสมการที่อยู่ใน Node นั้นซะ วิธีการแก้ไขนั้นผมจะไม่ขอลงรายละเอียดมากเพราะว่าเนื้อหาอาจจะระดับมหาลัย เลยครับ แต่ผมอุตส่าห์เกริ่นหัวอย่างดีว่า ไม่ใช่โปรแกรมเมอร์ก็อ่านได้
เอาแบบคราวๆก็เราจะผลลัพธ์ที่ได้จากการประมวลผลบน NN ใช่ไหมครับ เราเก็บผลลัพธ์อันนี้เอาไว้ แล้วอาจจะไปหักออกจากผลลัพธ์บน Sample หลังจากนั้นทำไงต่อ ไอ้ผลที่หักออกตรงนี้จะเป็นตัวแปรสำคัญในการปรับเปลี่ยน Node บนชั้น Hidden ครับ ซึ่งการปรับเปลี่ยนเนี่ยมันจะเป็นลักษณะของการลดทอน บวกเพิ่ม ข้อมูลต่างๆเข้าไปลงบน Node แต่ละตัว Node
ทำให้ Node แต่ละ Node เนี่ยสามารถแก้ไขตัวเองได้ โดยทำงานได้ถูกต้องตาม Sample ที่เราเตรียมเอาไว้ใคร
สมมุติผมกำหนดความเข้มของสี ตั้งแต่ 1 – 10 ยิ่งใกล้เลข 10 มากเท่าไหร่ แสดงว่ามีความเหมือนสีแดงมากเท่านั้น ยิ่งใกล้ 1 เท่าไหร่แสดงว่ามีความเหมือนสีเขียวมากเท่านั้น แล้วให้ผลลัพธ์ของการกินได้มีตั้งแต่ 1 – 10 โดย 1 คือกินไม่ได้และ 10 คือกินได้ Input คือ 1-10 บอกความเข้มสี และ Output คือ 1-10 คือกินได้
เราก็จะมีข้อมูลตัวอย่างดังนี้ (1,1) (2,3) (3,5) (4,4) (5,6) โดยให้วงเล็บแต่ละชุดนั้น ตัวเลขตัวหน้าคือความเข้มสี และ ตัวหลังคือกินได้หรือไม่ได้ เช่น (2,5) แปลว่า มีความเข้ม 2 และระดับกินได้เป็น 5
เราอาจจะเขียน NN โดยเริ่มต้นแล้ว ตอนที่ยัด Input เข้าไปเป็นเลข 1 NN อาจจะให้ Output ออกมาเป็น 10 ก็ได้
ซึ่งความจริงแล้วข้อมูลจริงๆเป็น (1,1) นั่นหมายความว่า Output ที่แท้จริงคือ 1 ไม่ใช่ 10 ดังนั้น NN จะต้องทำการแก้ไขกระบวนทำงานของมันเองโดยอาจจะนำเลข 10 – 1 = 9 แล้วนำเลข 9 นี่ไปแก้ไขสมการคณิตศาสตร์ที่อยู่ข้างใน Node แต่ละ Node (ที่เป็นสีส้ม)
ซึ่งการยัด Input กับ Output ตัวอย่างที่ให้ไปนั้นจะทำให้โครงสร้างของ Node ค่อยๆปรับเปลี่ยน อย่างเช่นภาพด้านบน กรณีที่ Output ที่ NN คำนวณออกมากับ Output ตัวอย่างไม่ตรงกัน มันก็พยายามไปแก้ Node ที่เป็นสีส้มเพื่อให้ Output มันออกมาได้ถูกต้อง
หลังจากปรับเปลี่ยนกระบวนและพัฒนา Node แต่ละอันจนเสร็จสิ้น เราก็จะได้ NN ที่สามารถคำนวณได้ว่าถ้าเราใส่ข้อมูลเลข 1 ลงไปมันจะตอบเลข 1 ออกมานะ
เราก็จะป้อนข้อมูลอย่างนี้ไปเรื่อยๆจนครบ หลังจากครบแล้ว Node แต่ละ Node ใน NN จะมีการแก้ไขการทำงานนับครั้งไม่ถ้วน แล้วทุกครั้งที่เอาข้อมูลใส่เข้าไปมันก็จะยิ่งฉลาดขึ้นเรื่อยๆ เพราะว่าความแม่นยำของข้อมูลจะสูงขึ้น ยิ่งข้อมูลมีจำนวนมากเท่าไหร่ การที่ NN จะคิดได้เหมือนตัวอย่างที่เราให้มาก็มีความแม่นยำสูงนั่นเอง
โดยกระบวนการที่ฉลาดนั้นเป็นการแก้ไขสมการคณิตศาสตร์ในแต่ละ Node ซึ่งเป็นการแก้ทีละนิดๆ พอมาประกอบกันเป็นก้อนใหญ่ทำให้ทำงานในภาพรวมได้ถูกต้อง
ซึ่งหลังจากที่ฉลาดมากพอแล้ว NN ก็จะให้ Output ที่แม่นยำมากขึ้น กรณีที่ป้อน Input ต่างๆเข้าไป
แต่…
Output
ที่ออกมานั้นอาจจะไม่ตรงตามข้อมูลจริงๆที่ป้อนเข้ามา เช่น Input เป็น 4
Output ของ NN หลังจากที่ฉลาดแล้วอาจให้คำตอบมาเป็น 5 ซึ่งจากด้านบน
คำตอบจริงๆแล้วเป็น (4,4)
แต่ว่าคำตอบที่ได้ก็มีความใกล้เคียงของจริงอยู่มากดังนั้นผมจึงสรุปให้ได้ว่า
คำ
ตอบที่คอมพิวเตอร์ที่ประมวลผลออกมาได้นั้น ไม่ใช่คำตอบที่ถูกต้องที่สุด
แต่ใกล้เคียงความจริงมากที่สุด
พูดง่ายๆคือโปรแกรมจะให้คำตอบที่ฉลาดที่สุดกลับมาเสมอ
Deep Learning
จริงๆ นี่เป็นแค่รายละเอียดเล็กน้อยเท่านั้น แต่อยากให้ความสำคัญกับการเรียกคำถูกคำผิดครับผมNeural Network นั้นจริงๆโครงสร้างมันไม่ได้ซับซ้อนเหมือนอย่างเครือข่ายของสมองเรานะ เราจะแบ่ง Node บน NN ได้ออกเป็น 3 กลุ่มใหญ่ๆ คือกลุ่มที่เป็น Input กลุ่มที่เป็น Output และกลุ่มที่ใช้ในการประมวลผลผมจะเรียกว่า Hidden Node
ซึ่งแต่ละ Node ก็มีเส้นโยงไปกันมาใช่ไหมครับ แต่สำหรับ NN แล้ว เราจะเห็นว่าถ้าดูเส้นเชื่อมดีๆแล้ว แล้วเราจัดกลุ่มของ NN จะได้ 3 กลุ่มคือ กลุ่มที่เป็น Input กลุ่มที่เป็น Output และกลุ่มที่เป็น Hidden ซึ่งข้อมูลจาก Input จะส่งไป Hidden และ Hidden จะส่งไปยัง Output
ซึ่งมันเป็นลักษณะของ Neural Network ที่มีเพียงแค่ 3 ชั้น แล้วถ้าเราลองเพิ่มจำนวนชั้น โดยให้ Hidden ส่งข้อมูลหา Hidden อีกทีก่อนที่จะส่ง Output ลักษณะนี้เรียกว่า Multi-Layer Neural Network หรือ Deep Neural Network หรือ Deep Learning ครับ
ไม่ใช่เพียงแค่จำนวนชั้นที่เยอะที่ทำให้ Deep Learning ต่างจาก Neural Network ธรรมดาซึ่งมีความซับซ้อนมหาศาล และมันเขียนยากกว่า NN มหาศาลครับ เพราะด้วยความที่ NN นั้นมีความซับซ้อนที่น้อยเลยทำให้เราสามารถทำนายของเล็กๆบางอย่างได้ถูกต้อง แต่การเขียน Deep Learning นั้นเราไม่สามารถเขียนลงไปตรงๆได้ อีกอย่างคือถึงแม้ว่าเราเขียนมาเสร็จแล้ว ก็ไม่การันตีว่าที่เราเขียนมานั้น พอเอาไปประมวลผลข้อมูลแล้วมันจะฉลาดขึ้นหรือเปล่า อาจจะฉลาดน้อยลงกว่าเดิมก็ได้
ซึ่ง Deep Learning ไม่ได้ใช้บน AlphaGo อย่างเดียวเท่านั้นนะครับ แต่ยังใช้บนพวกการประมวลภาพด้วยเช่น ตรวจสอบว่าภาพที่ให้มานั้น เป็นยาพาหนะประเภทอะไร ภาพที่ให้มานั้น คนมีอารมณ์ลักษณะอย่างไร สิ่งเหล่านี้อยู่บนพื้นฐาน Deep Learning ทั้งหมดครับ
Extra
แม้ว่า Neural Network จะเป็นการทำงานที่เลียนแบบสมองมนุษย์ได้ก็จริง แต่ไม่ได้หมายความว่ามันจะฉลาดเท่ามนุษย์นะครับ มันยังฉลาดน้อยกว่ามนุษย์มาก แต่อาจจะฉลาดกว่าสำหรับงานประเภทบางอย่าง เช่นการทำนายพยากรณ์อากาศ คอมพิวเตอร์จะฉลาดมากๆสำหรับงานที่เกี่ยวข้องกับตัวเลขโดยหากถ้าเราแปลงสิ่งต่างๆเป็นภาพของตัวเลขได้ นั่นหมายความว่าเราก็พร้อมเริ่มต้นที่จะเขียน Machine Learning ในระดับขั้นพื้นฐานได้
ในปัจจุบันนี้ Machine Learning ยังมีข้อจำกัดหลายอย่างคือ 1.ต้องการคนสร้าง 2.ต้องการกำลังการประมวลมหาศาล ถ้าหากคนสร้างสามารถสร้างคอมพิวเตอร์เลียนแบบความคิดมนุษย์ได้และมี เทคโนโลยีที่ก้าวหน้ามหาศาล ก็อาจจะทำให้เกิด iRobot ขึ้นได้ แต่ไม่ใช่ระยะเวลาใกล้ๆนี้แน่นอน เพราะฉะนั้นอย่าเข้าใจผิดนะครับว่า การที่ AlphaGo กำเนิดขึ้นมาอาจทำให้เกิดหุ่นยนต์ยึดครองโลก มันไม่ใช่แบบนั้นนะครับ 5555