เจาะลึก AlphaGo ทำงานอย่างไร ? (ฉบับเข้าใจง่าย ไม่เคยเขียนโปรแกรมก็อ่านได้)

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

มนุษย์ vs เครื่องจักร

ช่วงประมาณ 1 สัปดาห์ที่ผ่านมาหลายๆคนคงเห็นความเคลื่อนไหวมากมายบนโลก Social Network ที่ว่า Google ได้สร้างบอทมาแข่งเกมกระดานหมากล้อม (หรือที่เรียกกันว่า Go) มาแข่งกับ Lee Sedol นักเล่นโกะระดับ 9 ดั้ง (เป็นระดับสูงสุดของเกม Go) ซึ่งไม่ใช่บุคคลธรรมดาแต่เป็นบุคคลระดับโลกที่อยู่ในระดับแนวหน้าของเกม กระดาน Go อีกทั้งยังมีการถ่ายทอดสดให้ชมทั่วโลก
การแข่งขันครั้งนี้ค่อนข้างเป็นก้าวสำคัญของประวัติศาสตร์ได้เลย เพราะเป็นการแข่งขันระหว่างมันสมองหัวกะทิของมนุษย์ กับเครื่องจักรกลที่มีพลังในการประมวลมหาศาล ศึกนี้ใครจะชนะ

อะไรคือ Go

รูปภาพของกระดานโกะ

จริงๆที่ผมพูดไปบนย่อหน้าแรกก็ออกจะดูเว่อร์ไปหน่อย มันไม่ได้ถึงขั้นระดับ มนุษย์ vs เครื่องจักรเลยทีเดียว เพราะมันเป็นการแข่งขันที่อยู่บนกฏและกติกาของเกมกระดาน Go ซึ่งก่อนจะพูดถึงในส่วนต่อไป เรามาทำความเข้าใจรู้แบบการเล่นของกระดาน Go ก่อน (ต่อไปผมจะเรียกสั้นๆว่า Go นะครับ) Go หรือชื่อภาษาไทยคือหมากล้อม ก็ตรงๆเลยครับเป็นเกมที่คุณจะต้องล้อมพื้นที่ให้ได้มากที่สุด
จินตนาการว่าคุณสร้างบ้านหลังหนึ่งแล้วตีกำแพงรอบๆบ้าน อาณาเขตของบ้านคุณคือพื้นที่ที่โดนกำแพงล้อมไว้ Go ก็เช่นกัน แต่ Go เป็นการล้อมพื้นที่ด้วยหมาก ซึ่ง Go เป็นเกมที่มีผู้เล่น 2 คน ดำกับขาว แต่ละค่อยๆเริ่มลงหมากลงบนจุดตัดของกระดาน ลงไปเรื่อยๆจนกว่าจะทั้งคู่จะผ่าน หรือมีคนหนึ่งยอมแพ้ ซึ่งกติกาละเอียดๆนั้นจะไม่ขอพูดถึง แต่อาจจะช่วยให้คุณเห็นภาพรวมมากยิ่งขึ้นว่า Go นั้นดูอย่างไร
วิธีการดูคร่าวๆก็ดูบนอาณาเขตที่ว่างๆนั่นแหละครับ ช่วงต้นเกมอาจจะมองไม่ออกว่าล้อมอย่างไร แต่กลางเกมอาจจะเริ่มเห็นว่า พื้นที่ว่างๆเหล่านี้ถูกล้อมด้วยหมากสีอะไรหมายกกว่ากัน
โอเคครับ จบละครับสำหรับการเกริ่น Go อย่างคร่างๆ ไปเรื่องที่น่าสนุกต่อไปกันดีกว่า

อะไรคือ AlphaGo

AlphaGo เป็นบอทที่เขียนด้วยทีมงานจาก Google ครับ
โดยคนที่เขียนเนี่ย ไม่คนที่เก่งเหนือว่า Lee Sedol ที่มีระดับตั้ง 9 ดั้งเลยนะครับ คนที่เป็นคนเขียนเนี่ยเขารู้แค่เพียงกติกา เงื่อนไขและการนับคะแนนของเกมเท่านั้น อาจจะรู้เทคนิคการเล่นเกม Go บ้างนิดหน่อย แต่ค่อนข้างการันตีได้แน่ๆว่าสิ่งที่พวกเขาสร้างมานั้น บางอย่างก็เลยขอบเขตที่มีอยู่อย่างจำกัดของพวกเขาแน่นอนครับ
ซึ่งเนื้อหาต่อไปที่ผมจะพูดถึงเนี่ย ไม่ใช่แค่เพียงเกม Go เท่านั้นนะที่สามารถเอากระบวนการทั้งหมดที่ผมจะพูดต่อมาใช้กับเพียงแค่เกม Go เกมเดียว แต่ยังรวมไปถึงเกมกระดานอื่นๆอีกมากมายพันแปด ไม่ว่าจะหมากล้อมหรือหมากฮอส
อ้าว คราวนี้หลายคนงงละ ว่ามันคือวิธีการอะไร แล้วถ้าคนที่เขียน AlphaGo เนี่ย ไม่ได้เก่งเหนือ AlphaGo แต่อย่างใด คำถามคือเขาสร้างสิ่งที่เก่งกว่าตัวเองได้อย่างไร
ใช่แล้วครับ สิ่งที่เขาสร้างนั้น เขาไม่สร้างวิธีการเล่นเกม แต่ที่เขาสร้างมานั้น คือการสร้างวิธีการเรียนรู้ด้วยตัวเองด้วยการป้อนเงื่อนไขของการเล่นเข้าไป ฟังดูอาจงงๆ เป็นคำพูดมนุษย์ธรรมดาก็คือ ทีมงานของ Google ได้สร้างโปรแกรมที่สามารถเรียนรู้ด้วยตนเองจนทำให้โปรแกรมมันเก่งกว่าคนที่ สร้างเองยังไงละครับ (กรุณาเปิดเพลง Inception ประกอบเพื่ออถรรส)

Part I : Introduction

ตรงนี้จะเป็นการอธิบายเชิงลึก (ที่จริงๆมันมีลึกกว่านั้นอีกหลายเท่า) ว่าการเรียนรู้ด้วยตัวเองของคอมพิวเตอร์เนี่ย มันเป็นลักษณะอย่างไร มันทำงานอย่างไร มีพื้นฐานจากอะไร
ซึ่งคุณสามารถข้ามไปอ่าน Part ที่ 2 ได้เลย เพราะว่า Section นี้ผมแทบไม่พูดอะไรเกี่ยวกับ AlphaGo ครับ
เรื่องที่ผมสนใจจะพูดถึงใน Part ที่ 1 คือ คอมพิวเตอร์ใช้วิธีการอะไรในการเรียนรู้ด้วยตนเองเป็นการอารัมภบทเพื่อเป็น ความรู้ให้แก่ผู้ที่สนใจครับ
เนื้อหาของ Part ที่ 1 จะยาวหน่อยนะครับ ผมเลยแยกบล็อกไปให้อีกบล็อกหนึ่งเพื่ออถรรสในการอ่าน ถ้าสนใจคลิกได้ที่ http://blog.kosatestudio.com/2016/03/13/how-alphago-work-part-i/

Part II : AlphaGo

ถึงเวลาพูดถึงฮีโร่ของเราละครับ ถึง Part มันส์ๆซะทีครับ 5555
ใน Part นี้จะใช้ศัพท์เทคนิคเยอะมากนะครับ แต่จะพยายามเขียนให้เป็นภาษามนุษย์ให้เข้าใจมากที่สุดเท่าที่จะทำได้นะครับ หากมีอะไรสงสัยสามารถคอมเม้นท์ไว้ด้านล่างได้เลยครับ

Introduction

วิธีการในการแก้ปัญหา

สิ่งที่ผมกำลังจะพูดต่อไปนี้มันเป็นวิธีที่การที่สามารถนำไปประยุกต์กับ เกมกระดานต่างๆได้อย่างมากมายมหาศาล ไม่ใช่เพียงแค่เกมโกะอย่างเดียว สิ่งที่ทีมงาน Google ได้สร้างขึ้นมานี้มีพื้นฐานมาจากสิ่งที่เรียกว่า Machine Learning หรือให้เจาะจงกว่านั้นคือ Neural Network ซึ่งเป็นการกระบวนแก้ปัญหานี้ โดย Machine Learning เป็นกระบวนการที่ทำให้คอมพิวเตอร์สามารถเรียนรู้ได้ด้วยตนเอง
ส่วน Neural Network นั้นจะเป็นวิธีที่การที่เลียนแบบการทำงานของสมองมนุษย์ คือในสมองของมนุษย์จะมีเซลล์มากมายหลายล้านเซลล์ แต่ละเซลล์ต่างเชื่อมต่อกันและส่งข้อมูลหากันในแต่ละเซลล์ เช่นเดียวกันกับ Neural Network คอมพิวเตอร์ก็จะจำลองเหมือนสมองมนุษย์ คือสร้างเซลล์ที่ทำหน้าที่รับข้อมูล (Input) ต่างๆเข้ามาแล้วทำการประมวลเพื่อส่งข้อมูล (Output) ต่อไปยังเซลล์อื่นๆ หลังจากสร้างเสร็จเราก็จะได้โครงข่ายอันซับซ้อนของแต่ละเซลล์ที่ส่งข้อมูลหา กัน ผ่านกระบวนการทางคณิตศาสตร์ที่ได้แปลงค่าๆหนึ่งเป็นค่าอีกค่าหนึ่ง
ซึ่ง AlphaGo ก็ได้ใช้วิธีนี้ในการทำนายว่า ถ้าหากเราเจอกระดานที่มีรูปแบบแบบนี้ ตาต่อไปเราควรทำอย่างไร สำหรับรายละเอียดจะพูดถึงต้องไป แต่ให้เข้าใจประเด็นหลักๆที่จะพูดถึงคือคอมพิวเตอร์นั้นเรียนเป็นครับ แต่เรียนบนสมการคณิตศาสตร์นับพันตัวที่ทำงานบนคอมพิวเตอร์ที่สามารถคำนวณตัว เลขหลักล้านตัวได้พริบตาเดียว

ทุกความเป็นไปได้ ?

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

อ่า จริงๆแล้วทำได้ครับ แต่มันเป็นแค่ความคิดในอุดมคติครับ เพราะอะไร ? เพราะว่าเกมกระดานโกะนั้นค่อนข้างแตกต่างจากหมากรุก หมากฮอสและหมากอื่นๆอย่างมาก เพราะจำนวนวิธีในการวางหมากที่มากถึง 19 x 19 = 361 ช่อง ดังนั้น จำนวนวิธีที่ทั้งหมดที่เป็นไปได้ของการเดินหมากบนกระดานโก๊ะคือ

208168199381979984699478633344862770286522453884530548425639456820927419612738015378525648451698519643907259916015628128546089888314427129715319317557736620397247064840935

ตัวเลขอ้างอิงจาก Number of legal Go positions

ซึ่งมากกว่าจำนวนอะตอมในจักรวาลเสียอีก

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

เนื้อหาทางเทคนิค

การที่เราคำนวณการเดินของหมากในอนาคตนั้นเราจะเรียกว่า Searching ตามที่ได้อธิบายใน Part I ซึ่งการคำนวณทุกตาเดินที่เป็นไปได้หรือเรียกว่า Brute Force นั้นกินพลังในการประมวลผลและเครื่องมืออย่างมหาศาล จึงต้องใช้ Solution อื่นๆในการแก้ปัญหาดังที่กล่าวไว้คือ Machine Learning

Step 0 : Mathematical

ก่อนอื่นเราต้องเข้าใจว่ากระดานโกะเนี่ยเวลาที่คนมองกับ AlphaGo มองไม่เหมือนกันนะ สำหรับคนมองอาจจะมองเห็นเป็นหมากสีขาวหรือสีดำ อะไรทำนองนี้
แต่ สำหรับ AlphaGo แล้วมันมองเห็นเป็นเลข 1 -1 0 ซึ่ง 1 ก็คือหมากของเรา -1 ก็คือหมากของศัตรู แล้วเอาตัวเลขนี้ไม่ร้อยเรียงกันซึ่งเรียกกันว่า Matrix Matrix คือชุดของตัวเลขที่มีลักษณะเหมือนตาราง โดย Matrix ของเกมโกะจะเป็น Matrix ที่มีขนาด 19×19 ตามจุดตัดบนตารางโกะ แล้ว AlphaGo ก็จะมองเห็นสิ่งเหล่านี้เป็นตัวเลขแล้วนำตัวเลขพวกนี้ไปประมวลผลอีกที
แน่นอนผลลัพธ์ที่ออกมาก็ต้องเกี่ยวข้องกับตัวเลข ไม่ใช่ตัวเลขตัวเดียวนะครับ แต่เป็นตัวเลขหลายชุดนับไม่ถ้วน แล้วเอาตัวเลขพวกนั้นมาแปลงเป็นรูปแบบของการเดินบนกระดานอีกที จำไว้นะครับ

AlphaGo มองทุกอย่างเป็นตัวเลข ไม่ใช่สิ ไม่ใช่แค่ AlphaGo เราต้องบอกว่า “คอมพิวเตอร์” มองทุกอย่างเป็นตัวเลขครับต่างหากครับ

Step 1 : Begin from human

อันดับแรก AlphaGo จะสร้างโปรแกรมมาโปรแกรมหนึ่ง ที่จะทำนายการเดินของหมากในอนาคต โดยการสังเกตุการจากรูปแบบหมากบนกระดาน ถ้าหากกระดานเป็นรูปแบบอย่างนี้ ต่อไปแล้วเราควรลงหมากที่ตำแหน่งไหน ซึ่งยังไม่รวมถึงการทำนายอนาคต แต่เป็นลักษณะของการเรียนรู้ (Learning) จาก “รูปแบบของกระดาน” ว่าถ้าหากเจอกระดานลักษณะอย่างนี้แล้ว ตาต่อไปเราควรลงหมากแบบไหน
แน่นอนครับว่ามันเรียนรู้รูปแบบของกระดานจากมนุษย์ครับ AlphaGo จะรวบรวมข้อมูลการเล่นโกะใน KGS เป็นพิ้นที่สำหรับให้คนเล่นเกมโกะแบบออนไลน์ครับผม
โดยข้อมูลที่รวบรวมมานั้นผ่านการกรองมาแล้วว่าเป็นผู้เล่นระดับเซียน AlphaGo ก็นำข้อมูลพวกนี้ไปเรียนรู้ และใช้ข้อมูลไปมากถึง 30 ล้านชุดเลยทีเดียว
เรียนรู้ว่าการเดินหมากตาต่อไป (ต่อไปจะขอย่อคำว่า “การเดินหมากตาต่อไป” ว่า move) ควรจะอยู่ตำแหน่งไหนของกระดาน โดยเรียนรู้จากลักษณะการเล่นของคน โดยจะป้อนข้อมูลการเล่นของแต่ละคนเข้าโปรแกรมนี้
ซึ่งไม่สนใจว่าสุดท้ายแล้วเกมจะแพ้หรือเกมจะชนะ แค่สนใจว่า move ต่อไปของผู้เล่นนั้นจะเป็นอย่างไร เมื่อป้อนข้อมูลให้ครบทุกคนโปรแกรมนี้ก็จะฉลาดขึ้นในระดับหนึ่งที่สามารถ ทำนายได้ว่าหากเจอกระดานที่มีลักษณะแบบนี้ ตาต่อไปเราควรต้องลงหมากที่ตำแหน่งไหน แต่นี่ยังไม่รวมการทำนายล่วงหน้าว่าผู้เล่นฝ่ายตรงข้ามจะเดินหมากแบบไหนแล้ว เราควรปรับเปลี่ยนกลยุทธิ์อย่างไร
ซึ่งหลังจากที่โปรแกรมเรียนรู้เสร็จ เราก็จะได้โปรแกรมที่มีลักษณะการทำงานดังนี้

• เมื่อเราป้อน Matrix ของเกม Go เข้าไป
• สิ่งที่ได้ออกมาแค่ Matrix อีกชุด ที่บอกว่าความน่าจะเป็นของจุดต่างๆที่ควรลงหมากครับ

แล้วโปรแกรมก็จะเลือกตำแหน่งที่มีความน่าจะเป็นสูงสุดมาลงครับ แน่นอนว่าข้อมูลพวกนี้นั้นมีพื้นฐานมาจากรูปแบบการเดินของมนุษย์ ดังนั้นรูปแบบการลงหมากของ AlphaGo จึงคล้ายคลึงกับมนุษย์มาก ด้วยการสอนมันด้วยข้อมูล 30 ล้านชุด ซึ่งก็พบว่ามันสามารถทำนายการเดินหมากของคนที่เล่นโกะระดับสูงๆได้แม่นยำถึง 57% เลยทีเดียว
เพื่อความเข้าใจในการอ่านบทความต่อไป ผมจะเรียกโปรแกรมที่สร้างเสร็จจากขั้นตอนนี้ว่า Next-Move Basic (แน่นอนครับว่ามันยังมีอีกหลายโปรแกรมในอนาคต อันนี้แค่ขั้นแรก)

เนื้อหาทางเทคนิค

AlphaGo ได้ใช้ Convolutional Neural Network (CNN) ซึ่งมีพื้นฐานมาจาก Deep Learning (Neural Network ที่มีจำนวน Hidden Layer หลายชั้น) โดย CNN นั้นประกอบไปด้วย Hidden Layer จำนวน 13 ชั้นครับ แล้วก็ยัดข้อมูลการเล่นเกมของแต่ละคนลงบน CNN
แล้วก็ให้ CNN เรียนรู้ข้อมูลการเดินหมากของคนโดยใช้ Supervised Learning
กำหนดให้ Input คือ Matrix ของกระดานและ Output คือตำแหน่งของ
ซึ่งวิธีการที่ AlphaGo ใช้นั้นเป็น Supervised Learning คือ Learning จาก Data ที่มีอยู่
กำหนดให้ Input ก็คือรูปแบบของกระดาน Output ก็คือ Matrix ความเป็นไปได้ที่จะลงหมากที่ตำแหน่งต่างๆ
แล้วทาง Paper ได้เรียก CNN ตัวนี้ว่า SL Policy Network (SL ก็ย่อมาจาก Supervised Learning)

Step 2 : Bot vs Bot

และแล้วก็ถึงเวลาอัพเกรดโปรแกรมครับ โปรแกรมที่ได้จากขั้นตอนแรกนั้น มันก็ฉลาดระดับหนึ่งครับแต่ยังฉลาดไม่พอ


Google ก็จับ Next-Move Basic 2 ตัว มาแข่งกันเองครับ โดยหลังจากที่แข่งเสร็จก็จะปรากฏผลแพ้ ผลชนะหรือรายละเอียดต่างๆมากมายของเกม เช่น แต้มที่ได้บนกระดาน ซึ่งข้อมูลต่างๆหลังจากที่เกมเล่นจบเนี่ย จะเป็น feedback กลับมาที่ตัวโปรแกรมเองว่าการวางหมากแบบนี้จะส่งผลให้แพ้หรือชนะ
ซึ่งหลังจากเสร็จแล้วในแต่ละตาก็จะจับคู่กับตัวเองในเวอร์ชั่นที่พัฒนา แล้วอีกระดับหนึ่ง เล่นไปเรื่อยๆแล้วก็เรียนรู้ไปเรื่อยจาก feedback จนเก่งขึ้นเรื่อยๆ หลังจากเสร็จสิ้นตัวโปรแกรมจะมีลักษณะคล้ายๆ Next-Move V1 แต่มีจุดที่แตกต่างคือ มันจะไม่เลือกเดินหมากที่อาจทำให้แพ้ได้ จะเลือกเพียงแค่หมากที่มีโอกาสสูงที่ทำให้ชนะเท่านั้น โดยการวิเคราะห์แพ้หรือชนะนั้นมาจากการเรียนรู้ที่เล่นกับตัวเอง
ซึ่ง AlphaGo ได้นำ Next-Move Basic มาแข่งกับตัวเองเป็นจำนวน 1,0000,000 ครั้ง จนพบว่า AlphaGo เวอร์ชั่นที่ล้านนั้น เมื่อมาแข่งกับครั้งแรกก่อนพัฒนา พบว่ามีโอกาสชนะมากกว่าสูงถึง 80%
ซึ่งต่อไปผมจะเรียก AlphaGo เวอร์ชั่นที่แข่งกับตัวเองเสร็จแล้วว่า Next-Move Optimal

เนื้อหาทางเทคนิค

คราวนี้ AlphaGo ไม่ได้ใช้ Supervised Learning เพราะว่าไม่มีตัวอย่างข้อมูลป้อนเข้ามาให้เรียนรู้ สังเกตุดีๆนะครับว่าครั้งนี้เป็นการเรียนรู้จาก feedback ดูว่าการเล่นลักษณะแบบนี้ทำให้เกิดผลแพ้หรือชนะ ซึ่งเป็นลักษณะ NN ที่สังเกตุว่า ถ้าเรา move แบบนี้ (action) จะส่งให้เกิดผลลัพธ์ (feedback) กลับมาอย่างไรบ้าง ถ้าการเดินนั้นทำให้เกมแพ้ โปรแกรมก็จะเรียนรู้ว่าการเดินแบบนี้อาจทำให้เดินแพ้ได้ ซึ่งเป็นการ Learning จาก Feedback โดยยัด Action ต่างๆเข้าไปแล้วก็ Feedback จะปรับปรุง Node ใน NN (หรือ CNN) จนเริ่มดีขึ้นเรื่อยๆ
วิธีนี้เรียกว่า Reinforcement Learning ครับ แล้วไอ้เจ้าตัว NN ที่ปรับปรุงตัวเองหลังจากแข่งกับตัวเองล้านครั้งแล้วเรียกว่า RL Policy Network (RL ย่อมาจาก Reinforcement Learning)

Step 3 : Fast

อันนี้จะเป็นเหมือนอันแรกครับ แต่เป็นเวอร์ชั่นที่เร็วกว่าอันแรกมาก ถามว่าทำไมต้องสร้างมาทำไม ในเมื่อเราก็มีตัวที่สามารถคำนวณ Next-Move ที่ยอดเยี่ยมได้แล้ว คำตอบคือ Next-Move Basic มันช้าระดับนึงครับ แต่จะเอาไว้สำหรับเล่นเกมเร็วก็ไม่ถูกเลยทีเดียวครับ ซึ่งไอ้ตัวโปรแกรมนี้จะใช้อีกทีใน Step 5 ครับ
โปรแกรมตัวนี้จะเรียนจาก move ของศัตรูครับ ศัตรูวางหมากไว้ตรงไหนมันก็จะ Learning วิธีการหมากรอบๆศัตรูครับ ซึ่งไม่ใช่การ Learning บนกระดานทั้งกระดาน 19×19 จึงทำให้วิธีนี้รวดเร็วมาก ซึ่งข้อมูลที่ใช้ในการ Learning ก็เป็นข้อมูลชุดเดียวกันกับข้อ 1 นั่นแหละครับ เพียงแต่จำกัดอาณาเขตให้เล็กลง ซึ่งการประมวลผลนั้นเร็วกว่า
ผมขอตั้งชื่อโปรแกรมนี้ว่า Rollout นะครับ ซึ่งระลึกไว้เสมอนะครับว่าตัว Rollout เนี่ย เน้นคิดเร็วนะครับ แต่ไม่ได้เน้นประสิทธิภาพ คำตอบที่ออกมาเนี่ยมันจะสวนทางกับ Next-Move Basic เลย เพราะว่า Next-Move Basic เนี่ยจะให้ข้อมูลที่แม่นยำในระดับหนึ่ง แต่เพราะว่าเป็นการคิดข้อมูลครอบคลุมทั้งกระดาน 19×19 เลยทำให้การทำงานของมันเที่ยงตรงมาก สำหรับเวอร์ชั่น Rollout ก็มีประสิทธิภาพระดับหนึ่งครับ แต่มันเน้นสำหรับพื้นที่แคบๆ เน้นคิดเร็ว แต่ไม่เน้นความถูกต้องมากมาย
แล้วมันใช้ทำอะไรละ เดี๋ยวกล่าวไปใน Step 5 ครับ เอ้อ Rollout เป็นโปรแกรมที่ Learning จากชุดข้อมูลเดียวกันกับ Next-Move Basic นะครับ เป็นชุดข้อมูลของการเดินของคน ไม่ใช่มาจาก Next-Move Optimal นะครับ อย่าเพิ่งจำสับสน

เนื้อหาทางเทคนิค

ใช้ Supervised Learning เช่นเดียวกันกับ Step 1
แต่ลดจำนวน Node ลง (เพราะไม่ต้องคิดทั้งกระดาน) จึงทำให้ประสิทธิภาพในการประมวลนั้นเร็วขึ้นมาก ผมไม่ค่อยมีข้อมูลส่วนนี้มาก (เอาตรงๆก็ไม่รู้เรื่อง 555) รู้สึกจะเป็นลักษณะของ hard code (คือใส่เงื่อนไข กฏนู้นนี่นั่นเข้าไปแล้วทำให้ผลลัพธ์ออกมาลักษณะอย่างไรก็ขึ้นอยู่กับ เงื่อนไข) บางส่วน บางส่วนก็เป็น Pattern Matching คือถ้าได้ Pattern ลักษณะแบบนี้มาจะต้องลงแบบไหนถึงจะดีอะไรประมาณนี้ครับ โดยดูจากรูปแบบกระดานของคน แล้วสังเกตุ Pattern แล้วจับยัดๆ ซึ่งระลึกไว้นะครับว่า Rollout มันไม่ได้กินพื้น 19×19 ดังนั้นมันไม่ได้ทำ Pattern Matching ทั้งกระดานนะครับ
แต่โดยพื้นฐานแล้ว Rollout ก็มีพื้นฐานมาจาก NN ครับ มีการคิดที่เป็นส่งข้อมูลโยนแบบ Node ต่อ Node ดังนั้นเขาจึงตั้งชื่อตัวนี้ว่า Rollout Network

Step 4 : Value

Step นี้แตกต่างจาก 2 Step แรกอย่างมาก เพราะว่า 2 Step แรกนั้นเราจะได้โปรแกรมที่ทำหน้าที่คิด move ถัดไป แต่สำหรับอันนี้จะเป็นการคิดหาความเป็นไปได้ที่จะชนะ (Possibility)
โดยการหยิบ Next-Move Optimal 2 ตัวมาแข่งกัน แล้วก็เก็บข้อมูลของการเดินแต่ละตาเอาไว้ หลังจากนั้นก็จะมี feedback กลับมาซึ่งเหมือนกัน Step 2 เลย เพียงแต่ว่าการ Learning ครั้งนี้จะเป็นการ Learning บน รูปแบบกระดานปัจจุบัน กับ move ต่อไปที่จะลง ซึ่งการ Learn นั้นจะเป็น Learn วิธีการคำนวณความเป็นไปได้ว่า ถ้าลง move แบบนี้ความน่าจะเป็นที่จะชนะนั้นเป็นเท่าไหร่
อาจจะคล้ายคลึงกับ Step 2 แต่ข้อแตกต่างคือ Feedback นั้นไม่ได้เอามาวิเคราะห์ว่าหมากที่ควรลงต่อไปคือหมากตัวไหน แต่เป็นการวิเคราะห์ว่าถ้าลงหมากแบบนี้โอกาสชนะนั้นเป็นเท่าไหร่
หลังจากปล่อยให้โปรแกรมทำการเก็บข้อมูลการเดินของ Next-Move Optimal จนเสร็จ และ Learning การทำนายความน่าจะเป็นที่ชนะจนเสร็จสิ้นแล้ว เราก็จะได้โปรแกรมที่สามารถคำนวณได้ว่า ถ้าให้รูปแบบกระดานแบบนี้และ move แบบนี้มา เราจะมีโอกาสชนะมากน้อยเท่าไหร่ ซึ่งค่าที่ได้เป็นค่าประมาณนะครับ ไม่ใช่ค่าที่ถูกต้องมากแต่ทำให้ค่อนข้างแม่นยำระดับหนึ่ง
ผมจะขอตั้งชื่อโปรแกรมตัวนี้ว่า Value Calculation

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

เนื้อหาทางเทคนิค

ครั้งนี้ก็เป็น Reinforcement Learning อีกรอบครับ Input ก็ได้แก่รูปแบบกระดานและ move ต่อไปครับ ส่วน Output ก็เป็นโอกาสที่จะชนะ ทาง Paper ได้เรียก CNN หลังจากเรียนรู้วิธีการคำนวณความเป็นไปได้ของการชนะนี้ว่า Value Network

Step 5 : Reduce Searching

มาถึง Step ที่วายป่วงกันได้เลยครับ 55555
สำหรับ Step นี้เป็น Step ที่พูดถึงการคิดแทนศัตรูละครับ จะเห็นว่าทั้ง 3 Step ที่กล่าวมาทั้งหมด และได้โปรแกรมออกมา 3 โปรแกรมที่ทำหน้าที่แตกต่างกันนั้น จะเห็นว่าทุกอันยังไม่ได้แตะต้องกับการทำนายอนาคตเลยแม้แต่นิดเดียวนะครับ มาถึงส่วนที่เป็นฮีโร่และคิดว่าน่าจะซับซ้อนที่สุดแล้วสำหรับการทำนายอนาคต
แต่จะเห็นว่าผมเคยพูดถึงการคำนวณทุกวิธีที่เป็นไปได้ใน Step 0 แล้วว่าเลขมันใหญ่มหาศาล มันทำไม่ได้ ถ้ามันเยอะเราก็ทำให้มันน้อยลงสิครับ โดยการพิจารณาถึงรูปแบบกระดานที่เกี่ยวข้องและรูปแบบการเดินหมากในอนาคตที่ อาจส่งผลต่อเกม ถ้าการเดินหมากนั้นที่จะจินตนาการในอนาคตไม่ส่งผลต่อรูปเกมเราจะคิดทำไม
AlphaGo ก็ใช้พื้นฐานตรงนี้ในการคิดครับ มันก็จะพยายามจินตนาการถึงวิธีที่จำเป็นที่ส่งผลต่อรูปเกม จะได้ไม่เสียเวลากรณีคิดวิธีอื่นๆ

วิธีการ

1. ขั้นแรกเราจะเลือก ความเป็นไปได้ของ move ต่างๆบนโปรแกรม Next-Move Basic มาก่อน โดยอาจจะหยิบหมากสัก 5-6 move ที่มีความเป็นไปได้สูงสุดแล้วมาคิดอะไรทำนองนี้ครับ
(จริงๆ AlphaGo ทดลองเลือก Next-Move Optimal แล้วครับ แต่ก็ไม่ใช่เพราะว่าจำนวน move สำหรับตาถัดไปมันน้อยครับ สาเหตุเนื่องจาก Next-Move Optimal มันผ่านกระบวนการคัดเลือก กลั่นกรองมาอย่างดีจนทำให้ตัวโปรแกรมตอบแต่ move ที่ดีที่สุด ไม่เลือก move อื่นๆเลย)แล้วก็เอา move แต่ละอันมาลองคำนวณอนาคตดูว่าแต่ละอันมีแนวโน้มอย่างไร
2. สำหรับขั้นตอนที่ 2 นั้นมี 2 วิธีที่ AlphaGo จะเลือกใช้ (แต่โดยมากใช้คู่กัน)
วิธีแรกคือคำนวณรูปแบบการวางหมากในอนาคต
โดยใช้โปรแกรม Rollout ในการคำนวณการทำงานในอนาคต เราอาจจะคำนวณล่วงหน้าไปสัก 10-20 ขั้น หรือขั้นสุดท้ายเลยก็ได้หากมีเวลาเหลือเฟือ เนื่องจาก Rollout เป็นโปรแกรมที่ทำงานได้เร็วมากทำให้คอมพิวเตอร์สามารถสร้างการคำนวณล่วงหน้า บน Rollout ได้เยอะมากๆ ถ้าใช้ตัวอื่นอาจทำให้การคำนวณช้ามากๆๆๆ และเสียเวลาโดยใช่เหตุครับ
วิธีที่ 2 คือการนำ Value Calcution มาบอกคำตอบให้เราเลยว่า ถ้าหากเรา move แบบนี้นะ จะมีโอกาสมากน้อยเพียงไรที่จะชนะ
แต่การใช้ Value Calculation เสียอย่างนึงคือมันคิดช้าว่าแบบ Rollout มากครับดังนั้นโดยปกติแล้วโปรแกรมจะจำลองวิธีที่ทั้ง 2 แบบให้ช่วยกันอย่างละครึ่งแล้วถ่วงน้ำหนักความน่าจะเป็นของหมากที่ควรลง 50/50
3. ขั้นสุดท้าย เลือก move ที่ดีที่สุดจากการคำนวณรูปแบบอนาคต ว่าแบบไหนให้โอกาสชนะสูงสุด ก็ลง move นั้นไป
4. แล้วก็ทำอย่างนี้ไปเรื่อยๆกับ move ถัดๆไปในอนาคตครับนี่คือวิธีการทั้งหมดที่ AlphaGo ใช้ครับ
จะเห็นว่าวิธีการนี้เป็นการประยุกต์โดยการนำโปรแกรมทุกอย่างที่เราสร้าง มาใน Step 1-4 มารวมกัน เดิมทีการใช้โปรแกรม Next-Move Basic กับ Next-Move Optimal ก็เพียงพอแล้ว
แต่หากเป็นการคำนวณถึงอนาคต คอมพิวเตอร์นั้นจะต้องบริหารเวลาให้ได้มากที่สุดโดยการสร้างบางสิ่งบางอย่าง เพื่ออาจอำนวยต่อการประมวล เช่น Rollout ที่คำนวณ move ต่อไปจากบริเวณรอบๆได้เร็วมหาศาล หรือการสร้างโปรแกรม Value Calculation เพื่อคำนวณความเป็นไปได้ของ move ได้ทันท่วงที โดยไม่ต้องคำนวณอนาคตหลายๆชั้น
เพราะว่า Value Calculation มันคำนวณความเป็นไปได้ของรูปแบบการเดินล่วงหน้าไปหลายชั้นๆไว้ล่วงหน้าอยู่ แล้ว ดังนั้นเราจึงไม่ต้องคำนวณอนาคตลึกๆลงไปแต่ใช้ Value Calculation มาตัดหางก่อนที่จะมองภาพชั้นต่อๆไปเลย
ซึ่งการใช้ Value Calculation มาช่วยในการจำกัดการคำนวณล่วงหน้าลึกค่อนข้างมีประสิทธิภาพมาก แต่อาจทำงานได้ช้ากว่าแบบ Rollout ซึ่งการทำงานของ Rollout นั้นเร็วกว่า Value Calculation ถึง 15,000 เท่าเลยทีเดียว แน่นอนว่าการใช้ Next-Move Basic กับ Next-Move Optimal มันเสียเวลากว่า Rollout แน่นอนดังนั้นเขาจึงเอา Rollout มาใช้ในการคำนวณเชิงลึกที่มองเห็นภาพอนาคตหลายๆชั้น ซึ่งไม่เน้นความแม่นยำสูง แต่เน้นแม่นยำระดับปานกลางแต่ทำงานได้เร็วดีกว่า
ซึ่งทาง AlphaGo ก็ใช้วิธีการมองภาพอนาคตทั้ง 2 แบบผสมกัน ทั้งแบบ Value Calculation และ Rollout แล้วนำทางสองรูปแบบมาคำนวณเป็นเปอร์เซ็นต์อย่างละ 50/50 แล้วดึงผลลัพธ์ที่ทำให้ตัวเกมมีโอกาสชนะสูงสุดออกมา
และนี่ก็คือสมองทั้งหมดของ AlphaGo ครับ ซึ่งสิ่งที่ผมพูดมาทั้งหมดเนี่ยอาจจะไม่ถึง 10% ของเนื้อหาจริงๆด้วยซ้ำ เนื้อหาจริงๆมันมีอะไรแยกย่อยเยอะแยะเต็มไปหมดเลยครับ แต่เนื้อหาที่ไม่ถึง 10% นี้ก็ทำให้ผมเปิดหูเปิดตาได้มากเลยทีเดียว ต้องกราบงามๆให้แก่ทีมงาน AlphaGo ทุกคนครับ

เนื้อหาทางเทคนิค

จะเห็นว่าคำนวณอนาคตนี้เป็นลักษณะของการ Searching AlphaGo ได้ใช้ Monte Carlo Tree Search (MCTS) สำหรับแก้ปัญหาเรื่องการทำนายอนาคต จากที่เห็นจะเห็นว่ารูปแบบของ MCTS ที่ AlphaGo มาใช้นั้น จะเป็นลักษณะของการไม่คำนวณทุกความเป็นไปได้
แต่คำนวณจากทางเลือกที่ดีที่สุดจากขั้นตอนแรกคือการเลือก move จาก Next-Move Basic ที่ได้มาจากการ Supervised Learning บนข้อมูลการเดินของมนุษย์ ซึ่งการเลือก move ที่ดีที่สุดยังไม่เพียงพอต่อการคำนวณ ก็ยังได้มองหาอนาคต โดยการใช้ Rollout ในการจำลองกระดานในอนาคตที่ลึกลงไปหลายๆชั้นด้วยความเร็วสูง
แต่จุดหนึ่งที่ผมชอบมากคือ Value Calculation ที่ทำให้เราไม่ต้องจำลองกระดานแบบลึกๆเหมือน Rollout เราสามารถดูผลลัพธ์ได้เลยว่าถ้าวาง move แบบนี้จะดีมากน้อยเพียงใด
ซึ่งการที่เราเลือก move จาก Next-move Basic โดยไม่จำเป็นต้องเลือก move ทุก move บนกระดานคือการ Breadth Reduction
ส่วนการที่เอา Value Calculation มาล็อกไม่ให้เราต้องเสียเวลาคำนวณชั้นต่อไปคือ Depth Reduction
จินตนาการถึงกระดานโกะที่มีความเป็นไปได้ 361 ทางเลือก และแต่ละทางเลือกอาจจะแยกได้อีก 360 ทางเลือก ซึ่งอาจจะมีจำนวนตาเดินถึง 300 กว่าตา
แต่การทำ Breadth Reduction ทำให้ทางเลือกแต่ละครั้งน้อยลงอย่างมหาศาล บวกกับ Depth Reduction ทำให้บอท Go ครั้งนี้เป็นบอทที่ดีที่สุดในประวัติศาสตร์เกม Go
จะเห็นว่าวิธีนี้เป็นการผสมผสานของ Network ทั้ง 3 อัน คือ SL Policy Network, Value Network และ Rollout Network โดยผ่านกระบวนการของ MCTS ที่แค่แต่ละตัวก็แข็งแกร่งในตัวของตัวเองแล้ว แล้วยิ่งเอามารวมกันอีกยิ่งปีศาจเลยครับ

Posscript (Technical)

เนื้อหาส่วนนี้จะค่อนข้างไปทางเชิงเทคนิคเล็กน้อยนะครับ ข้ามไปอ่าน Part 3 ได้เลยครับ ถ้าไม่ต้องการข้อมูลเบื้องลึกอะไรมาก

สรุปคร่าวๆครับ จากภาพด้านบนจะเห็นว่าตอนนี้เรามี Neural Network อยู่ 4 ชุด แต่ละชุดเกิดจากข้อมูล 2 ชุด โดยจะมี Rollout Policy กับ SL Policy Network ที่เกิดจากการเรียนรู้บน move ของผู้เล่นระดับ expert และ RL Policy Network เกิดจากการจับ SL Policy Network มาแข่งกันจนปรับปรุงได้เวอร์ชั่นฉลาด หลังจากนั้นก็เอา SL Policy Network มา generate move ทั้งหมดแล้วเอาแต่ละ move มาสร้างเป็น Value Network
ซึ่ง 4 สิ่งนี้เป็นสิ่งที่เตรียมพร้อมก่อนลงการแข่งขันจริง คือมี Network ระดับเทพอยู่กับตัวแล้ว 4 ชุด แล้วพอมาแข่งจริงก็ run โดยใช้ MCTS ซึ่ง MCTS ก็ทำงานเป็น step ดังนี้

• ดึงจำนวน move ที่สำคัญจาก SL Policy Network (สาเหตุที่ไม่ใช้ RL ได้กล่าวไปแล้ว)
• ทำ Searching โดยการแตกกิ่งจากจำนวน move ในขั้นตอนแรก ซึ่งรูปแบบการ Seach จะมี 2 แบบ คือ แบบแรกแตก tree ไปเรื่อยๆโดยใช้ Rollout Network ในการ Generate move ชั้นต่อไปเรื่อยๆ หรือแบบที่ 2 คือดึง possibility จาก Value Network โดยปกติแล้วจะใช้ 2 วิธีผสมผสานกัน แล้ว weight น้ำหนักคนละครึ่ง (50/50)

นี่คือกระบวนการทั้งหมดของ AlphaGo ครับ
นอกจากนี้ AlphaGo ยังได้ลอง แจงบอทเป็นความสามารถต่างๆ โดยอาจจะไม่ใช่ครบทั้ง 4 Network อาจจะมีลดบางอย่างออกไป และยิ่งมาผสมกันความแข็งแกร่งของ AlphaGo ก็จะยิ่งสูงขึ้นมากเท่านั้น
จะเห็นว่าแค่ Rollouts อย่างเดียวนั้นก็ไต่ไประดับแถวๆ 1500 ได้ (โดยทั่วไปแล้วระดับโลกจะอยู่ Rank ที่ประมาณ 3000 คน ระดับ Ranking แบบนี้เป็นระบบ Elo Rating ครับ ใช้สำหรับ Ranking บนเกม 2 players ที่นิยมไปทั่วโลกครับ) ซึ่งก่อนหน้าผมได้บอกว่าระบบ Rollouts เป็นระบบที่เน้นความเร็ว ไม่เน้นความแม่นยำ แต่จะเห็นว่าขนาดไม่แม่นยำยังไต่ Rank ได้สูงขนาดนี้ ไม่ต้องพูดถึงตัวอื่นเลย
ถัดไปก็เป็นพวก Policy Network และ Value Network ก็ตามคาดครับ Value Network พัฒนามาจาก RL Policy Network ที่แข็งแรงแล้วทำให้ Ranking สูงกว่า Policy Network ทั่วไป สุดท้ายก็มาจบด้วยผสมผสานทั้ง 3 รูปแบบ จะเห็นว่ามันสามารถไต่ได้เกือบถึงคนระดับโลกได้เลย (ข้อมูลตรงนี้อาจจะใช้คอมพิวเตอร์ระดับกลางๆ ซึ่งใน Paper จะมีการประมวลผลบนซูเปอร์คอมพิวเตอร์อีก ซึ่งเทพกว่าเดิมไปอีกขั้น)

Part III : Summarize

ความน่ากลัวของ AlphaGo

AlphaGo มีพื้นฐานมาจาก Deep Learning (เป็นเรื่องที่แยกย่อยมาจาก Machine Learning อีกที) ซึ่งเป็นวิธีการที่ค่อนข้างจะ Advance อย่างมาก ทีมงานที่พัฒนาตัวบอทตัวนี้ทุกคนล้วนจบดอกเตอร์มาทั้งนั้น และมีดีกรีความเป็น Google อยู่ด้วย พวกเขาได้สรรสร้างเครื่องมืออันอัจฉริยะที่ยอดเยี่ยมมากๆขึ้นมาอันหนึ่งเลย ทีเดียว
ลองสังเกตุดีๆนะครับ AlphaGo มีพื้นฐานมาจากการจดจำ แยกแยะและสังเคราะห์รูปแบบการเดินหมากโกะของมนุษย์ในระดับ Expert ก่อน แล้วเอาข้อมูลจำนวนประมาณล้านชุดมาวิเคราะห์ เรียนรู้ จนตัวเองสามารถเล่นโกะได้เทียบเคียงเท่ามนุษย์ในระดับ Expert แต่แค่นั้นมันยังไม่พอ AlphaGo ได้ลองแข่งกับตัวเอง โดยไต่ระดับจากความเทพของตัวที่มีอยู่แล้วให้เทพขึ้นไปอีก เพื่ออุดช่องโหว่หลายจุดที่อาจเกิดขึ้นจากมนุษย์ได้ จนกลายมาเป็น AlphaGo ระดับเซียน
ซึ่งนี่ยังไม่รวมวิธีที่การที่คิดล่วงหน้า ก่อนจะคิดล่วงหน้า มันได้ทำสิ่งหนึ่งที่คิดว่าเหนือมนุษย์ไปแล้วคือการคำนวณความเป็นไปได้ (Possibility) ที่วางหมากแบบนี้แล้วจะนำเกมไปสู้การแพ้หรือชนะซึ่งออกมาเป็นตัวเลขที่มี ความละเอียดสูง แม้แต่มนุษย์เองก็ไม่สามารถคาดเดาได้อย่างแม่นยำว่าการวางหมาก ณ จุดตรงนี้จะทำให้เกมมีแนวโน้มแพ้หรือชนะ ได้แค่ใช้สัญชาตญาณหรือวิเคราะห์อย่างคร่าวๆว่า หมากตรงนี้น่าลง ตรงนี้ไม่น่าลง
ผนวกกับ AlphaGo เวอร์ชั่นคิดเร็ว ที่สร้างมาไว้เพื่อใช้สำหรับสถานการณ์ที่อาจจะต้องคิดล่วงหน้าหรือทำนายเกม ในอนาคตไปหลายๆชั้น การคิดไปหลายๆชั้นเราอาจไม่ต้องเน้นหมากที่ดูดีที่สุด แต่เป็นหมากที่เทียบเคียงกับดูดีที่สุดแต่ให้ประสิทธิในการคิดเร็วกว่าหลาย เท่า จึงทำให้ AlphaGo ใช้วิธีการคิดล่วงหน้าแบบเร็วมหาศาลได้
แล้วเมื่อเอากรรมวิธีทั้ง 3 แบบข้างต้นที่กล่าวไปมารวมกัน ไม่แปลกครับที่มันเหนือกว่ามนุษย์ได้ แต่ระลึกไว้เสมอนะครับว่าจุดเริ่มต้นของความฉลาด AlphaGo นั้น มาจากการเรียนรู้จากรูปแบบการเดินของมนุษย์ !

คอมพิวเตอร์ก็เรียนรู้ได้

จะเห็นว่าจากที่ผมกล่าวมาทั้งหมดนั้น ตัว AlphaGo ฉบับสุดท้ายที่มาแข่งกับ Lee sedol ได้นั้น เป็นตัวที่ผ่านกระบวนการ Machine Learning มาอย่างสาหัสกว่าจะได้โปรแกรมสุดท้ายกลับมา โปรแกรมได้ทำหน้าที่เรียนรู้วิธีการเล่นของโกะก่อนที่จะมาสนามจริงๆก่อน หลังจากเรียนรู้เสร็จเราก็จะได้ตัวโปรแกรมหน้าตาอัจฉริยะๆ แล้วเอาตัวโปรแกรมอัจฉริยะนั้นมาแข่งกับผู้เล่น
ถ้าให้เริ่มโปรแกรมตั้งแต่ 0 และคิดใหม่ทุกครั้งที่เล่น ไม่ทันการณ์ครับ หมดเวลาพอดี จึงสรุปได้ว่าการทำให้คอมพิวเตอร์สามารถคิดได้ด้วยตัวเองก่อน แล้วพัฒนาความฉลาดขึ้นเรื่อยๆ มันเป็นเรื่องที่เป็นไปได้แล้วครับสำหรับโลกยุคนี้

โลกของ Machine Learning

ทุกวันนี้ Google น่ากลัวขึ้นทุกๆวันครับ (ไม่เกี่ยว 55555)
ทุกวันนี้เครืองจักรก็เริ่มน่ากลัวขึ้นทุกวัน จริงๆไม่ใช่เครื่องจักรหรอกครับ แต่คนที่สร้างอะไรพวกนี้ต่างหากที่น่ากลัว จะเห็นได้ชัดเจนว่าการที่เราจะสร้างเครื่องจักรให้คิดอะไรสักอย่างนั้น มันมีกระบวนอะไรต่างๆมากมาย อาจจะมีหลายคนที่เปิดหูเปิดตาว่า เฮ้ย การที่คอมพิวเตอร์เรียนรู้ด้วยตนเองนี้มันมีจริงๆหรือ มีจริงครับและใช้ในงานหลายๆอย่างโดยที่เราอาจจะยังไม่รู้ตัวด้วยซ้ำ
เอาที่เห็นภาพชัดสุดคือระบบ tag เพื่อนบน Facebook ที่แนะนำหน้าคนมาให้ อันนี้ก็มาจาก Machine Learning ครับ คำสั่งด้วยเสียงบนรถหรือบน Siri บน iPhone อันนี้ก็เป็น Machine Learning ครับ
ทุกวันนี้ Machine Learning สามารถตอบคำถามอะไรหลายอย่างได้มากมายและเริ่มเข้าสู่โลกยุคใหม่ที่จะให้คอมพิวเตอร์มาตอบคำถามแทนคน
แต่ผมว่าเป็นเรื่องที่ดีที่เราจะผลักดันให้วงการคอมพิวเตอร์ก้าวหน้าไปอีก ขั้นหนึ่งครับ หวังว่าเด็กน้อยตาดำๆอย่างผมคงเรียนตามทันเทคโนโลยีที่เร็วขนาดนี้

Credit

ข้อมูล ข้อความทั้งหมดที่ผมเขียนขึ้นนั้น บ้างก็เขียนเอง บ้างก็นำมาจากเว็บไซต์ต่างๆ บ้างก็นำมาจาก Paper ความรู้ก็งูๆปลาๆครับ หากมีข้อผิดพลาดประการใด discuss ที่ช่องคอมเม้นท์ด้านล่างได้เลยครับ ถ้าหากผิดพลาดประการใดก็ขออภัยมา ณ ที่นี้ด้วยครับ

• https://www.dcine.com/2016/01/28/alphago/ เว็บนี้เขียนดีมากครับ อาจมีเนื้อหาเกี่ยวกับคอมบ้างแต่ก็อาจง่ายดีครับ
• https://googleblog.blogspot.com/2016/01/alphago-machine-learning-game-go.html
• http://www.slideshare.net/ShaneSeungwhanMoon/how-alphago-works
• https://gogameguru.com/i/2016/03/deepmind-mastering-go.pdf อันนี้เป็น Paper ครับ ผมเข้าใจไม่ถึง 10% ครับ คาดว่าต้องใช้เวลาไม่ต่ำกว่าเดือนกว่าจะแกะเข้าใจ