นิวรัลเน็ตเวิร์ก: จาก Perceptron สู่ Deep Learning

วันที่ 10 มีนาคม 2016 ในเกมที่สองของซีรีส์ห้าแมตช์ที่กรุงโซล เครื่องจักรตัวหนึ่งชื่อ AlphaGo วางหมากสีดำลงบนแนวเส้นที่ห้าของกระดาน การเดินหมากนั้นแปลกจนผู้บรรยายที่เป็นมนุษย์คิดว่าเป็นความผิดพลาด มือโปรคนหนึ่งพูดออกมาว่ามือใหม่คนไหนเดินแบบนี้จะถูกตำหนิ Lee Sedol — แชมป์โลกโกะ 18 สมัย — ลุกขึ้นและเดินออกจากห้องเพื่อทำใจ

มันไม่ใช่ความผิดพลาด ห้าสิบตาต่อมา หมากตัวนั้น — ซึ่งเป็นที่รู้จักในชื่อ "ตาที่ 37" — คือจุดหมุนของทั้งเกม AlphaGo ชนะ Lee Sedol ผู้ถูกยกให้เป็นหนึ่งในนักเล่นที่ยิ่งใหญ่ที่สุดที่ยังมีชีวิตอยู่ แพ้ซีรีส์ 4–1 และนี่คือส่วนที่สำคัญ: ไม่มีมนุษย์คนใดสอนการเดินหมากนั้นให้ AlphaGo มันไม่มีอยู่ในตำราเล่มไหน เครื่องจักรค้นพบมันด้วยตัวเอง โดยเล่นเกมกับตัวเองนับล้านครั้ง และปรับตัวเลขภายในเล็ก ๆ นับพันล้านตัวจนกระทั่งเกิดรูปแบบขึ้นที่ไม่มีมนุษย์คนใดเคยเห็นมาก่อน

โกะมีตำแหน่งกระดานที่เป็นไปได้มากกว่าจำนวนอะตอมในเอกภพที่สังเกตได้ คุณไม่สามารถใช้กำลังดุ่ยเดา (brute force) กับมันได้ คุณไม่สามารถเขียนกฎขึ้นมาสำหรับมันได้ วิธีเดียวที่จะเล่นมันในระดับที่เหนือมนุษย์คือการ เรียนรู้ มัน — และสิ่งที่ทำการเรียนรู้นั้นคือ นิวรัลเน็ตเวิร์ก (โครงข่ายประสาทเทียม) กองหน่วยคณิตศาสตร์เรียบง่ายที่ ถ้ามีข้อมูลและการปรับแก้เพียงพอ สามารถค้นพบโครงสร้างที่ไม่มีมนุษย์คนใดจะอธิบายได้อย่างครบถ้วน

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

นิวรัลเน็ตเวิร์กทุกตัว — จากตัวกรองสแปมง่าย ๆ ไปจนถึง GPT ไปจนถึง AlphaGo — สืบเชื้อสายมาจากแนวคิดเดียว คือ perceptron ที่คิดค้นโดย Frank Rosenblatt ในปี 1958 มันคือโมเดลทางคณิตศาสตร์ที่ได้แรงบันดาลใจอย่างหลวม ๆ จากเซลล์ประสาททางชีววิทยา เซลล์ประสาทจริงรับสัญญาณไฟฟ้าผ่านเดนไดรต์ สะสมไว้ในตัวเซลล์ และยิงสัญญาณลงตามแอกซอนก็ต่อเมื่ออินพุตรวมข้ามเกณฑ์เท่านั้น perceptron ทำสิ่งเดียวกันนี้ แค่ใช้ตัวเลขแทนแรงดันไฟฟ้า

perceptron รับเวกเตอร์อินพุต x คูณอินพุตแต่ละตัวด้วย weight w ที่เรียนรู้มา บวกผลคูณทั้งหมด บวกเทอม bias b ที่ขยับเกณฑ์ และส่งผลลัพธ์ผ่าน activation function ถ้าผลลัพธ์ผ่านเกณฑ์ เซลล์ประสาทจะ "ยิง" ไม่เช่นนั้นก็จะเงียบ ทั้งหมดนี้คือนิพจน์กระชับตัวเดียว: output = f(w·x + b)

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

perceptron ตัวเดียวมีข้อจำกัดที่แข็งอยู่หนึ่งอย่าง คือมันสามารถแยกข้อมูลได้ด้วย เส้นตรง เท่านั้น (หรือในมิติที่สูงขึ้น ก็คือไฮเปอร์เพลนแบบเรียบ) มันตอบได้ว่า "จุดนี้อยู่เหนือหรือใต้เส้น?" แต่ตอบไม่ได้ว่า "จุดนี้อยู่ในบริเวณที่โค้งหรือไม่?" ตัวอย่างในประวัติศาสตร์คือปัญหา XOR — รูปแบบที่ perceptron ตัวเดียวไม่สามารถเรียนรู้ได้พิสูจน์แล้ว ข้อจำกัดที่ช่วยทำให้เงินทุนสนับสนุน AI แข็งตัวไปหลายปีในทศวรรษ 1970 ทางออกนั้นดูเรียบง่ายจนน่าขันเมื่อมองย้อนกลับ: กองซ้อน perceptron หลายตัวเข้าเป็นเลเยอร์ และแทรก activation แบบไม่เชิงเส้นระหว่างพวกมัน ทำแบบนั้น แล้วเครือข่ายที่เกิดขึ้นจะสามารถโค้ง พับ และแบ่งพื้นที่เป็นรูปทรงที่ซับซ้อนได้ตามใจ

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

• Input layer — จุดที่ feature ดิบของคุณเข้ามา: พิกเซลของภาพ คำในประโยค หรือสำหรับโมเดลการเทรด สิ่งอย่างราคา ปริมาณ ความผันผวน และความไม่สมดุลของออเดอร์บุ๊ก
• Hidden layers — เลเยอร์ในระหว่างนั้น ที่งานจริงเกิดขึ้น แต่ละเลเยอร์รับผลลัพธ์ของเลเยอร์ก่อนหน้าและประกอบมันขึ้นใหม่เป็น feature ที่เป็นนามธรรมมากขึ้น
• Output layer — คำตอบสุดท้าย: ความน่าจะเป็น การคาดการณ์ราคา หรือป้ายชื่อคลาส

คำว่า "deep" ใน deep learning หมายความง่าย ๆ ว่า hidden layer จำนวนมาก และความลึกให้สิ่งที่เฉพาะเจาะจง คือ ลำดับชั้นของ feature ในเครือข่ายที่ใช้กับภาพ เลเยอร์แรกตรวจจับเส้นขอบ เลเยอร์ต่อไปประกอบเส้นขอบเป็นรูปทรง เลเยอร์ต่อไปประกอบรูปทรงเป็นวัตถุ ไม่มีใครโปรแกรม "ตัวตรวจจับเส้นขอบ" หรือ "ตัวตรวจจับตา" — แนวคิดเหล่านั้น ปรากฏขึ้นเอง จากการฝึก เครือข่ายประดิษฐ์คำศัพท์ระดับกลางของตัวเองขึ้นมา

มีผลลัพธ์เชิงทฤษฎีที่สวยงามอยู่ตรงนี้ คือ universal approximation theorem: เครือข่ายที่มีแม้แต่ hidden layer เดียว ถ้ามีนิวรอนมากพอ สามารถประมาณค่าฟังก์ชันต่อเนื่อง ใดก็ได้ ให้มีความแม่นยำตามต้องการ กล่าวอีกอย่างคือ เครือข่ายที่ถูกต้องสามารถแทนรูปแบบใดก็ได้ที่มีอยู่ในข้อมูลของคุณในทางทฤษฎี ปัญหา — และเป็นปัญหาใหญ่ด้วย — คือคำว่า "ในทางทฤษฎี" นั้นทำงานหนักมาก ทฤษฎีนี้สัญญาว่าเครือข่ายแบบนั้น มีอยู่ มันไม่ได้บอกอะไรเลยว่าคุณจะ หา มันเจอหรือไม่ ว่าคุณมีข้อมูลมากพอที่จะระบุมันได้หรือไม่ หรือรูปแบบที่คุณไล่ตามนั้นเป็นจริงหรือไม่ ในโดเมนที่มีสัญญาณต่ำอย่างการเงิน ช่องว่างระหว่าง "แทนค่าได้" กับ "เรียนรู้ได้" นี้คือจุดที่โมเดลส่วนใหญ่ตายไปพอดี

นี่คือข้อเท็จจริงที่ทำให้คนแปลกใจ: ไม่มี activation functions ความลึกก็ไม่มีค่าเลย ถ้าทุกเลเยอร์เป็นเพียงผลรวมถ่วงน้ำหนักธรรมดา การซ้อนสิบเลเยอร์จะเหมือนกันทางคณิตศาสตร์กับเลเยอร์เดียว — ห่วงโซ่ของการดำเนินการเชิงเส้นจะยุบตัวลงเป็นการดำเนินการเชิงเส้นตัวเดียว คุณจะเสียเงินก้อนใหญ่ไปกับการคำนวณเพื่อสร้างเส้นตรงที่ประดับประดา Activation functions คือการหักงอแบบไม่เชิงเส้นที่แทรกอยู่ระหว่างเลเยอร์ที่ทำให้เครือข่ายโค้งได้ และการโค้งนี่เองที่ทำให้มันทรงพลัง

ค่า activation ที่ผู้ปฏิบัติงานทุกคนควรรู้:

• Sigmoid — σ(x) = 1/(1+e⁻ˣ) บีบอินพุตใดก็ได้ให้อยู่ในช่วง (0, 1) ซึ่งอ่านได้เป็นความน่าจะเป็นอย่างเป็นธรรมชาติ ดีสำหรับ output แบบไบนารี แต่เป็นตัวเลือกที่ไม่ดีนักในเลเยอร์ที่ซ่อนอยู่ เพราะสำหรับอินพุตบวกหรือลบขนาดใหญ่ เส้นจะแบนลง gradient ของมันเข้าใกล้ศูนย์ และการเรียนรู้จะหยุดชะงัก — ปัญหา vanishing gradient
• Tanh — output อยู่ในช่วง (−1, 1) และมีจุดศูนย์กลางเป็นศูนย์ ซึ่งช่วยการปรับให้เหมาะสม ยังคงอิ่มตัวที่ค่าสุดขั้ว แต่รุนแรงน้อยกว่า sigmoid
• ReLU — f(x) = max(0, x) ค่าเริ่มต้นสมัยใหม่สำหรับ hidden layer มันเรียบง่ายจนน่าขบขัน คำนวณได้ถูก และคง gradient ที่แข็งแรงสำหรับอินพุตบวกทั้งหมด ข้อบกพร่องของมันคือ "dying ReLU" คือ นิวรอนที่ถูกดันจนให้ผลลัพธ์เป็นศูนย์เสมอ อาจกลายเป็นเฉื่อยชาถาวร
• Leaky ReLU — f(x) = max(0.01x, x) ให้ gradient รั่วไหลเล็กน้อยผ่านสำหรับค่าลบ ซึ่งช่วยไม่ให้นิวรอนตาย
• GELU — ญาติที่นุ่มนวลและเชิงความน่าจะเป็นของ ReLU ที่เป็นมาตรฐานภายใน transformer อย่าง BERT และ GPT

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

ขั้นแรกคือ forward pass: ป้อนตัวอย่าง ให้มันไหลผ่านเลเยอร์ต่าง ๆ และอ่านการคาดการณ์ ขั้นที่สองคือการวัดว่าการคาดการณ์นั้นผิดมากแค่ไหนโดยใช้ loss function สำหรับการคาดการณ์ตัวเลข (ราคา) Mean Squared Error จะเฉลี่ยช่องว่างที่ยกกำลังสองระหว่างการคาดการณ์กับความจริง สำหรับ classification cross-entropy วัดว่าความน่าจะเป็นที่คาดการณ์ห่างจากคำตอบที่ถูกต้องแค่ไหน loss สูงหมายความว่า "ผิดมาก" เป้าหมายทั้งหมดของการฝึกคือการดันตัวเลขนั้นให้ลดลง

ขั้นที่สามคือส่วนที่ฉลาด: backpropagation โดยใช้ chain rule ของแคลคูลัส อัลกอริทึมนี้ทำงานย้อนกลับจาก loss ผ่านทุกเลเยอร์ และคำนวณ สำหรับ weight แต่ละตัวโดยเฉพาะ gradient — คำตอบของ "ถ้าฉันขยับ weight ตัวนี้ขึ้นเล็กน้อย error จะขึ้นหรือลง และมากแค่ไหน?" นี่คือกลไกที่ทำให้ยุค AI winter ละลาย Backprop ซึ่งได้รับความนิยมในทศวรรษ 1980 ทำให้สามารถกำหนดความรับผิดชอบข้าม weight นับล้านตัวได้อย่างมีประสิทธิภาพ แทนที่จะเดาสุ่ม

ขั้นที่สี่คือ gradient descent: ขยับ weight ทุกตัวเป็นก้าวเล็ก ๆ ไปในทิศทางที่ลด loss โดยใช้กฎ w = w − α × ∂L/∂w ลองนึกภาพยืนอยู่บนเนินเขาที่มีหมอกลง พยายามไปให้ถึงพื้นหุบเขา คุณมองไม่เห็นด้านล่าง แต่คุณรู้สึกได้ว่าทางไหนคือทางลงจากใต้เท้าคุณ ดังนั้นคุณจึงก้าวไปทางนั้นและทำซ้ำ learning rate α คือความยาวของก้าวเดินของคุณ และมันเป็นตัวปรับที่สำคัญที่สุดในระบบทั้งหมดก็ว่าได้ ใหญ่เกินไปคุณจะกระโดดข้ามหุบเขาและเด้งไปมาตลอดกาล เล็กเกินไปคุณจะคลานไปเรื่อย ๆ อย่างไม่มีที่สิ้นสุด หรือติดอยู่ในร่องกลางทางลง

มีสองการปรับปรุงที่คุณจะพบทันที Mini-batches: แทนที่จะอัปเดตหลังจากทุกตัวอย่างเดี่ยว (มีสัญญาณรบกวนมาก) หรือหลังจากชุดข้อมูลทั้งหมดเท่านั้น (ช้า) คุณอัปเดตหลังจากชุดเล็ก ๆ — โดยปกติ 32 ถึง 256 ตัวอย่าง — ซึ่งเสถียร เหมาะกับ GPU และเป็นจุดที่ดีที่สุดในทางปฏิบัติ และ Adam: optimizer ที่ฉลาดกว่าที่ให้ weight ทุกตัวมีความยาวก้าวแบบปรับตัวได้ของตัวเอง และเพิ่ม momentum เพื่อทำให้ gradient ที่มีสัญญาณรบกวนเรียบขึ้น Adam คือค่าเริ่มต้นที่สมเหตุสมผลสำหรับเริ่มโปรเจกต์เกือบทุกอย่าง — แม้ในการเงินที่มีสัดส่วนสัญญาณต่อสัญญาณรบกวนต่ำ คุณจะยังต้องปรับ learning rate, weight decay และจุดหยุดด้วยมือ

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

Dropout เป็นที่นิยมที่สุด ในแต่ละขั้นการฝึก นิวรอนทุกตัวมีความน่าจะเป็น p (บ่อยครั้งอยู่ที่ 0.2–0.5) ที่จะถูกปิดชั่วคราว ถูกบังคับให้ทำงานแม้ตอนที่เพื่อนร่วมงานสุ่มยังหายไปเรื่อย ๆ เครือข่ายจึงเรียนรู้ที่จะกระจายความรู้ของมันไปยังนิวรอนหลายตัว มากกว่าที่จะพนันทุกอย่างไว้กับนิวรอนบาง ตัวที่บอบบาง — ผลกระทบแบบ ensemble ที่ฝังอยู่ในโมเดลเดียว ในเวลาทำนาย นิวรอนทั้งหมดจะเปิดกลับมา โดยปรับสเกลตามความเหมาะสม

L1 และ L2 penalties เพิ่มภาษีสำหรับ weight ขนาดใหญ่ลงใน loss L2 (weight decay) กีดกัน weight ตัวใดตัวหนึ่งไม่ให้ใหญ่เกินไป กระจายอิทธิพลให้เท่าเทียมกัน L1 คมกว่า มันขับ weight ที่ไม่มีประโยชน์ไปที่ ศูนย์เป๊ะ ๆ ทำการเลือก feature โดยอัตโนมัติ ในชุดข้อมูลการเงินที่ feature ส่วนใหญ่จากร้อยตัวเป็นสัญญาณรบกวน L1 สามารถค้นพบไม่กี่ตัวที่ถือสัญญาณจริงได้อย่างเงียบ ๆ

Batch normalization ปรับสเกลผลลัพธ์ของแต่ละเลเยอร์ให้มีค่าเฉลี่ยและความแปรปรวนที่มั่นคง ซึ่งทำให้การฝึกมั่นคงขึ้นและให้คุณใช้ learning rate ที่สูงขึ้นได้ Early stopping คือตัวป้องกันที่ง่ายที่สุดและน่าเชื่อถือที่สุด: เฝ้าดู error บนชุดข้อมูล validation ที่กันไว้ และในวินาทีที่มันเริ่มเลื้อย ขึ้น ขณะที่ error ในการฝึกยังลดลงต่อไป ให้หยุด — จุดตัดนั้นคือช่วงเวลาที่แน่นอนที่เครือข่ายเปลี่ยนจากการเรียนรู้รูปแบบเป็นการจดจำสัญญาณรบกวน

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

Convolutional Neural Networks (CNN) ถูกสร้างมาเพื่อภาพ แทนที่จะเชื่อมทุกพิกเซลกับทุกนิวรอน CNN เลื่อน ฟิลเตอร์ เล็ก ๆ ผ่านอินพุต ล่ารูปแบบเฉพาะที่ — เส้นขอบตรงนี้ พื้นผิวตรงนั้น — และใช้ฟิลเตอร์ตัวเดียวกันซ้ำทุกที่ เลเยอร์แรกจับเส้นขอบ เลเยอร์ที่ลึกกว่าประกอบมันเป็นรูปทรงและวัตถุ ในการเงิน นักวิจัยได้ชี้ CNN ไปที่:

• ภาพ กราฟแคนเดิลสติก — วางกรอบการอ่านกราฟใหม่ให้เป็นงานการจดจำรูปแบบเชิงภาพ
• Heatmap ของออเดอร์บุ๊ก — จับความไม่สมดุลของอุปสงค์/อุปทานในภาพถ่ายความลึกของตลาด
• 1D convolution บนลำดับราคาดิบ — เรียนรู้รูปแบบระยะสั้นตามเวลาแบบเดียวกับที่ CNN ภาพเรียนรู้รูปแบบเชิงพื้นที่

Recurrent Neural Networks (RNN) ถูกสร้างมาเพื่อลำดับ พวกมันประมวลผลทีละช่วงเวลา ขณะที่พา hidden state — ความทรงจำที่ทำงานอยู่ — จากแต่ละช่วงไปยังช่วงต่อไป ในทางทฤษฎีสิ่งนี้ทำให้พวกมันเหมาะกับ time series อย่างยิ่ง ในทางปฏิบัติ RNN ธรรมดาถูกจำกัดโดยปัญหา vanishing gradient เมื่อลำดับยาว สัญญาณจากหลายช่วงก่อนหน้าจะหดตัวเข้าใกล้ศูนย์ในทางกลับ ดังนั้นเครือข่ายจึงลืมอดีตที่ห่างไกลไปเลย

Long Short-Term Memory (LSTM) เครือข่ายแก้ปัญหานี้ด้วยชุด gate ที่เรียนรู้ได้เล็ก ๆ — forget, input และ output — ที่ตัดสินใจในแต่ละช่วงว่าจะลบอะไรจากความทรงจำ จะเขียนอะไรลงไป และจะอ่านอะไรออกมา การใช้ gate นั้นทำให้ LSTM สามารถเก็บข้อมูลที่เกี่ยวข้องไว้ข้ามหลายร้อยช่วง ซึ่งเป็นเหตุผลที่มันกลายเป็นเครื่องมือหลักสำหรับการสร้างโมเดล time series ทางการเงินที่เหตุการณ์จากเมื่อวานยังคงขับเคลื่อนราคาของวันนี้

import torch.nn as nn

class PricePredictor(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers):
        super().__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim,
                            num_layers, batch_first=True,
                            dropout=0.2)
        self.fc = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

บนแพลตฟอร์มอย่าง GaiaEx ที่ WebSocket feed สตรีมข้อมูลราคาและออเดอร์บุ๊กอย่างต่อเนื่อง LSTM สามารถรับลำดับนั้นได้อย่างเป็นธรรมชาติ อย่างไรก็ตาม สาขานี้ได้เคลื่อนไปข้างหน้ามากแล้ว: transformer — สถาปัตยกรรมที่อยู่หลังโมเดลภาษาสมัยใหม่ — ตอนนี้เทียบเท่าหรือเหนือกว่า LSTM บนงานลำดับหลายอย่าง โดยใช้ "attention" ในการมองทุกช่วงเวลาพร้อมกัน แทนที่จะเดินผ่านทีละช่วง

นิวรัลเน็ตเวิร์กเป็นตัวค้นหารูปแบบที่ยอดเยี่ยม แต่การศึกษาที่ตรงไปตรงมาหมายถึงการชี้ให้เห็นว่าพวกมันพังตรงไหน — และในการเทรด พวกมันพังในทางที่มีค่าใช้จ่ายสูง

• มันพบรูปแบบแม้ในตอนที่ไม่มีอยู่จริง ให้สัญญาณรบกวนกับเครือข่ายลึก แล้วมันจะปรับตัวให้เข้ากับมันอย่างมั่นใจ ตลาดส่วนใหญ่คือสัญญาณรบกวน ดังนั้นภาระในการพิสูจน์อยู่ที่คุณที่ต้องแสดงว่ารูปแบบนั้นเป็นจริงและคงอยู่ต่อเนื่อง — ไม่ใช่แค่ปรากฏในข้อมูลปีที่แล้ว
• มันเป็นกล่องดำ โมเดลอาจแม่นยำและยังไม่สามารถบอกคุณได้ว่า ทำไม เมื่อมันเสียเงินขึ้นมาทันที มักไม่มีคำอธิบายที่ชัดเจนและไม่มีทางแก้ที่ชัดเจน สำหรับเงินทุนที่รับความเสี่ยง "ฉันไม่รู้ว่าทำไมมันทำแบบนั้น" คือภาระผูกพันที่ร้ายแรง
• มันหิวและบอบบาง Deep learning ทำงานได้ยอดเยี่ยมกับตัวอย่างที่สะอาดนับล้านตัว ประวัติศาสตร์การเงินสั้น ไม่นิ่ง และมีสัญญาณรบกวน — ระบอบที่ฝึกโมเดลของคุณอาจหยุดมีอยู่ไปเลย ปัญหาที่เรียกว่า distribution shift
• มันไม่ชนะโมเดลที่ง่ายกว่าโดยไม่มีค่าใช้จ่าย บนข้อมูลแบบตาราง (tabular) ที่อิงจาก feature ที่พบทั่วไปในการเงิน gradient-boosted tree อย่าง XGBoost มักจะ เหนือกว่า นิวรัลเน็ตเวิร์ก ในขณะที่ฝึกได้เร็วกว่าและตีความง่ายกว่า ความซับซ้อนคือค่าใช้จ่าย ไม่ใช่คุณธรรม
• มันสามารถถูกโจมตีได้ การรบกวนเล็ก ๆ ที่ตั้งใจกับอินพุตสามารถพลิก output ของเครือข่ายได้ — adversarial example — ซึ่งสำคัญในทุกที่ที่ฝ่ายตรงข้ามสามารถกำหนดสิ่งที่โมเดลของคุณเห็นได้

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

GPU คือมาตรฐาน คอร์นับพันของมันทำงานเดียวกันบนข้อมูลที่แตกต่างกันพร้อม ๆ กัน ซึ่งพอดีกับรูปทรงของคณิตศาสตร์นิวรัลเน็ตเวิร์ก โมเดลที่คลานอยู่ 8 ชั่วโมงบน CPU สามารถเสร็จได้ใน 15 นาทีบน GPU สมัยใหม่ NVIDIA ครองตลาด: การ์ดสำหรับผู้บริโภค (GPU ระดับ RTX) เพียงพอสำหรับการเรียนรู้ ในขณะที่การ์ดระดับ data center (A100, H100) และอินสแตนซ์คลาวด์จัดการการฝึกในระดับผลิตจริง TPU ชิปที่ Google ออกแบบเองสำหรับคณิตศาสตร์ tensor โดดเด่นกับโมเดลขนาดใหญ่มากผ่าน Google Cloud แต่ GPU ยังคงเป็นค่าเริ่มต้นเชิงปฏิบัติสำหรับผู้ปฏิบัติงานส่วนใหญ่ เนื่องมาจากการรองรับซอฟต์แวร์ที่กว้างกว่า

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

เส้นทางการเรียนรู้ที่สมเหตุสมผลจากที่นี่:

• เริ่มด้วยเครือข่าย feedforward ธรรมดาบน feature ที่ออกแบบไว้ไม่กี่ตัว — ฝึกเร็ว ดีบักง่าย และเป็นเส้นฐานที่ตรงไปตรงมา
• ลอง 1D CNN บนลำดับราคาดิบ และเทียบมันแบบตัวต่อตัวกับเส้นฐานนั้น
• สร้าง LSTM ที่รับลำดับข้อมูลแคนเดิลสติกจาก API ของ GaiaEx
• ศึกษา attention และ transformer — สถาปัตยกรรมที่ถูกเลือกใช้มากขึ้นเรื่อย ๆ สำหรับลำดับ
• เหนือสิ่งอื่นใด เทียบโมเดลลึกของคุณกับเส้นฐาน gradient-boosting อย่าง XGBoost เสมอ ถ้านิวรัลเน็ตเวิร์กไม่สามารถเอาชนะโมเดลที่ง่ายกว่าแบบ out-of-sample บนข้อมูลการเงินแบบตารางของคุณได้ ให้ใช้โมเดลที่ง่ายกว่าและก้าวต่อไป

ลูปเดียวกันที่ค้นพบตาที่ 37 — คาดการณ์ วัด error ขยับ weight ทำซ้ำ — คือลูปที่กำลังทำงานอยู่ในทุกระบบในรายการนี้ เข้าใจลูปนั้นแล้วคุณจะเข้าใจ deep learning ส่วนที่เหลือคือสถาปัตยกรรมและวิศวกรรมที่สร้างบนมัน