RNNs เคยเป็นทุกอย่างหรือเปล่า?

• แม้ว่า Transformer จะเข้ามาปรับโฉมดีปเลิร์นนิงตั้งแต่ปี 2017 แต่เมื่อเจอกับ ลำดับที่ยาวมาก ต้นทุนของ self-attention จะสูงขึ้น ทำให้โมเดลแบบวนซ้ำที่ฝึกแบบขนานได้กลับมาได้รับความสนใจอีกครั้ง
• LSTM และ GRU ซึ่งถูกใช้อย่างแพร่หลายกับงาน sequence modeling ตลอด 20 ปีก่อนยุค Transformer สามารถเปิดทางสู่การฝึกแบบขนานได้ หากลดการพึ่งพาสถานะก่อนหน้าของ gate
• minLSTM และ minGRU ที่ถูกทำให้ง่ายลง มีพารามิเตอร์น้อยกว่า LSTM·GRU แบบเดิม, ขนานได้เต็มที่ระหว่างการฝึก, และให้ประสิทธิภาพที่แข่งขันได้กับโมเดลสมัยใหม่หลายแบบรวมถึง Transformer
• การทำให้ Transformer มีประสิทธิภาพมากขึ้นได้แตกแขนงไปสู่ความเบาบาง, การประมาณแบบ low-rank, และ tiling ขณะที่ช่วงหลังมานี้ โมเดลวนซ้ำทางเลือก อย่าง state space model, linearized attention และ linear RNN ก็แสดงประสิทธิภาพที่แข็งแกร่งเช่นกัน
• ด้วย implementation แบบ plain PyTorch เพียงไม่กี่บรรทัดในภาคผนวก ทำให้ minGRU และ minLSTM ถูกมองได้ว่าเป็น โมเดลน้ำหนักเบา ที่เหมาะให้ผู้เริ่มต้น ผู้ปฏิบัติงาน และนักวิจัยทดลองใช้งานได้ง่าย

---

โมเดลวนซ้ำที่กลับมาได้รับความสนใจหลังยุค Transformer

• RNN ถูกใช้อย่างแพร่หลายในงาน sequence modeling เช่น machine translation และ text generation มาตั้งแต่ทศวรรษ 1990
  • โมเดลตัวแทนคือ LSTM (1997) และ GRU (2014)
  • ด้วยโครงสร้างที่เป็นลำดับโดยเนื้อแท้ จึงขนานได้อย่างจำกัด และมักมีประสิทธิภาพการคำนวณลดลงเมื่อฝึกกับลำดับที่ยาว
• Transformer ประสบความสำเร็จอย่างรวดเร็วในงาน sequence modeling หลังจากนำกลไกการฝึกแบบขนานผ่าน self-attention มาใช้ในปี 2017
  • หลังจากนั้นก็ขยายไปไกลกว่ารุ่นภาษาขนาดใหญ่ ทั้งในคอมพิวเตอร์วิทัศน์, reinforcement learning และ bioinformatics
  • self-attention ใช้สร้างแบบจำลองปฏิสัมพันธ์ระหว่างโทเค็น แต่ความซับซ้อนในการคำนวณจะ เพิ่มขึ้นแบบกำลังสอง ตามความยาวของลำดับ
  • ในลำดับยาวหรือสภาพแวดล้อมที่ทรัพยากรจำกัด ต้นทุนนี้อาจสูงขึ้นมาก
• งานวิจัยเพื่อเพิ่มประสิทธิภาพของ Transformer เดินหน้าไปหลายทิศทาง
  • ความเบาบาง
  • การประมาณแบบ low-rank
  • tiling
• ระยะหลัง โมเดลวนซ้ำที่ขนานได้และขยายตัวได้อย่างมีประสิทธิภาพมากกว่ากำลังกลับมาโดดเด่นอีกครั้ง
  • state space model
  • linearized attention
  • linear RNN
  • โมเดลวนซ้ำสมัยใหม่เหล่านี้ใช้การเปลี่ยนผ่านที่ขึ้นกับอินพุต และแสดงประสิทธิภาพที่แข็งแกร่งใกล้เคียงกับ Transformer
  • ไม่ได้ใช้แค่กับรุ่นภาษาขนาดใหญ่ แต่ยังนำไปใช้กับข้อมูลภาพและข้อมูลแบบกราฟได้ด้วย

แนวคิดหลักของ minLSTM และ minGRU

• งานวิจัยนี้ย้อนกลับไปทบทวน LSTM และ GRU ซึ่งถูกใช้งานมาอย่างยาวนานก่อนยุค Transformer จากมุมมองเชิงประวัติศาสตร์
• ทั้งสองโมเดลสามารถมองได้ว่าเป็นตัวอย่างยุคแรกของ โมเดลวนซ้ำที่ขึ้นกับอินพุต
• หากตัดส่วนที่ gate พึ่งพาสถานะก่อนหน้าออกไป LSTM และ GRU ก็จะสามารถ ฝึกแบบขนาน ได้เช่นกัน
• ด้วยการทำให้ง่ายลงเพิ่มเติม จึงได้เวอร์ชันขั้นต่ำชื่อ minLSTM และ minGRU
  • มีจำนวนพารามิเตอร์น้อยกว่า LSTM·GRU แบบเดิม
  • ขนานได้เต็มที่ระหว่างการฝึก
  • แม้โครงสร้างจะเรียบง่าย แต่ก็ให้ประสิทธิภาพที่แข่งขันได้ในหลายงาน
  • โมเดลที่ใช้เปรียบเทียบมีทั้งโมเดลสมัยใหม่รวมถึง Transformer
• ผลลัพธ์นี้ตั้งคำถามต่อแนวโน้มที่ยังคงเพิ่มทั้งโครงสร้างของโมเดลและความซับซ้อนของอัลกอริทึมอย่างต่อเนื่อง
• ในภาคผนวกมี implementation แบบ plain PyTorch ของ minGRU และ minLSTM อยู่ในโค้ดเพียงไม่กี่บรรทัด
  • โมเดลมีน้ำหนักเบาและปรับใช้ได้ง่าย
  • อยู่ในรูปแบบที่ผู้เริ่มต้น ผู้ปฏิบัติงาน และนักวิจัยนำไปใช้ได้สะดวก

[GN⁺]

ความคิดเห็นบน Hacker News

• ถ้ามองโครงสร้างแบบวนซ้ำเป็นฟิลเตอร์ IIR และโครงสร้างแบบ feedforward ล้วนเป็นฟิลเตอร์ FIR ก็เหมือนจะมีจุดคล้ายกับการประมวลผลสัญญาณดิจิทัลอยู่มาก
  ฟิลเตอร์ IIR มักต้องใช้องค์ประกอบน้อยกว่าฟิลเตอร์ FIR ที่ให้การตอบสนองแบบเดียวกันมาก ส่วนฟิลเตอร์ FIR มักนำไปใช้งาน ควบคุม และวัดผลได้ง่ายกว่า
  รู้สึกว่าฮาร์ดแวร์เลขคณิตแบบจุดคงที่คล้ายกับโครงสร้างแมชชีนเลิร์นนิงที่รันได้ดีบน GPU และถ้า AI จะก้าวไปสู่ขั้นแบบทวีคูณที่น่ากลัวจริง ๆ ก็ดูเหมือนว่าจำเป็นต้องมีโครงสร้างที่เป็นแบบวนซ้ำโดยพื้นฐาน
  ในอุปมานี้ LSTM ใกล้เคียงกับการแฮ็กกึ่งกลางแบบ FIR ที่มีสัมประสิทธิ์แบบไดนามิก และในระยะยาวแนวทางแบบนิวโรมอร์ฟิกดูจะดีที่สุดในแง่ประสิทธิภาพ

  • จากมุมมองการประมวลผลสัญญาณ เอาต์พุตของ IIR มีช่วงเสถียรภาพแคบ ขึ้นอยู่กับตำแหน่งโพลของฟังก์ชันถ่ายโอนของฟิลเตอร์หลังแปลง z จึงมักต้องออกแบบอย่างระมัดระวัง
    ไม่เช่นนั้นฟิลเตอร์ IIR จะลดทอนแบบเอ็กซ์โปเนนเชียลจนเป็น 0 หรือเพิ่มขึ้นแบบเอ็กซ์โปเนนเชียลไปสู่อินฟินิตี้
    เซลล์ RNN อย่าง LSTM ใกล้เคียงกับฟิลเตอร์ลดทอนที่ใส่เกตไม่เชิงเส้นเพื่อป้องกันการลดทอนและ “จดจำ” บางสิ่ง
    ฟิลเตอร์ FIR ออกแบบง่ายกว่ามาก และสามารถเก็บความจำได้โดยไม่ต้องใช้การแฮ็กแบบนี้
  • อยากให้ช่วยอธิบายง่าย ๆ ว่าแนวทางแบบนิวโรมอร์ฟิกคืออะไร และช่วย AI/AGI ได้อย่างไร
    ในฐานะคนนอกวงการ ความประทับใจแรกคือมันดูคล้ายไอเดียแบบ 《The Society of Mind》ที่ไม่ใช่แค่จำลองนิวรอน แต่ให้ “เอเจนต์” หรือระบบย่อยหลายตัวโต้ตอบกันในหลายรูปแบบ
  • ผมเคยคิดมาสักพักแล้วว่า หากไม่มีโครงสร้างที่เป็นแบบวนซ้ำโดยพื้นฐาน AI จะไปไม่ถึงขั้นแบบทวีคูณที่น่ากลัว แต่ตอนนี้เริ่มสงสัยว่าแค่หน้าต่างบริบทขนาดใหญ่มากก็อาจเพียงพอหรือไม่
    ความเป็นแบบวนซ้ำอาจมีลักษณะนิวโรมอร์ฟิกมากกว่าและสำคัญในระยะยาว แต่ก็อาจไม่จำเป็นต่อซูเปอร์อินเทลลิเจนซ์
    อย่างไรก็ตาม ผมเป็นคนนอกที่มีความรู้ด้านนี้ตื้นมาก จึงอาจผิดโดยสิ้นเชิงก็ได้
  • สงสัยว่าในสถาปัตยกรรมแบบ GPU ปัจจุบัน การนำฟิลเตอร์ IIRไปใช้งานในสเกลใหญ่จะยังให้ประสิทธิภาพและการขยายสเกลที่ดีได้หรือไม่

• ทั้งวงการดูยังไม่พอสำหรับปัญหาขอบฟ้าระยะยาว
  วิธีแก้ที่ใช้กันกว้างขวางตอนนี้คือการขยายสเกล แต่ก็ยังห่างไกลจากขนาดขอบฟ้าที่สมองของสัตว์เลี้ยงลูกด้วยนมขนาดเล็กจัดการได้
  โมเดลอาจมีพารามิเตอร์เป็นล้านล้านตัว แต่ในงานระยะยาวและด้านประสิทธิภาพ สมองหนูก็น่าจะยังชนะอยู่
  ราวกับว่ามีอัลกอริทึมค้นหาขนาดเล็ก เรียบง่าย และงดงาม ที่ค้นหาเส้นทางเกือบเหมาะที่สุดภายใต้งบประมาณคำนวณเล็ก ๆ และเรียนรู้ต่อเนื่องไปได้
  ผมยังแอบอิจฉาว่าวันหนึ่งวิศวกรในอนาคตอาจแก้ปัญหาแบบนี้ได้ด้วย Jupyter notebook 100 บรรทัดบนแล็ปท็อป
  หากพบวิธีหรืออัลกอริทึมที่เหมาะกับปัญหาขอบฟ้าระยะยาว โมเดล 2 พันล้านพารามิเตอร์ก็อาจแซงโมเดลปัจจุบันได้แทบทุกด้าน ยกเว้นปัญหาการให้เหตุผลที่สั้นและสุดโต่ง
  แนวทางที่เป็นไปได้ที่ผมเคยคิดไว้คือการขยายมิติของโมเดลตามเวลาแทนที่จะไล่หาน้ำหนักที่สมบูรณ์แบบ
  ยิ่งมิติสูง ความจุในการจัดเก็บเชิงทฤษฎีก็ยิ่งมาก และอาจคล้ายโมเดล 2 ชั้นที่ชั้นหนึ่งทำงานเหมือนการซ้อนทับของจุดผิดปกติหลายจุด ส่วนอีกชั้นรู้วิธีใช้งานพวกมัน
  หากมองว่าภูมิประเทศของ loss มีค่าต่ำสุดหลายจุดสำหรับงานเฉพาะ ก็อาจสร้างโมเดลเดียวที่มีค่าต่ำสุดเฉพาะที่แทบไร้ขีดจำกัด หรือกล่าวอีกอย่างคือมีความจำในมิติที่สูงกว่า โดยจัดโครงสร้างโมเดลใหม่เมื่อจำเป็นเพื่อเคลื่อนที่ระหว่างค่าต่ำสุดเหล่านั้น
  หากสมองมนุษย์สร้างและตัดการเชื่อมต่อนับพัน ๆ จุดในแต่ละวัน การเชื่อมต่อเหล่านี้อาจกำลังบังคับทิศทางภูมิประเทศ loss ภายในให้เคลื่อนไปมาระหว่างค่าต่ำสุดต่าง ๆ ที่จำเป็นในระหว่างวันก็ได้

  • ใช่ วงการนี้ยังขาดจอกศักดิ์สิทธิ์อย่างปัญหาขอบฟ้าระยะยาว
    แต่การจำแนกอีเมลสแปมก็ไม่จำเป็นต้องใช้สมองหนู
    โมเดลขนาดใหญ่ที่มีพารามิเตอร์ตั้งแต่ 2 พันล้านตัวขึ้นไปยังคงหนักเกินไปและใช้งานจริงได้ยาก จึงใกล้เคียงกับการใช้งานเฉพาะทาง ขณะเดียวกันยังมีพื้นที่อีกมากสำหรับโมเดลเล็กที่ฉลาดและแก้เฉพาะปัญหาที่มีประโยชน์บนฮาร์ดแวร์และชุดข้อมูลที่จำกัด
    โมเดลที่ปรับขนาดได้ตามความต้องการก็เคยถูกทดลองมาแล้ว แต่ภายใต้งบพลังงานที่จำกัด มันไร้ประสิทธิภาพเกินไปหรือเพิ่มประสิทธิภาพได้ยาก
    ถึงอย่างนั้น หากจะขยายไปสเกลที่ใหญ่ขึ้นเรื่อย ๆ สุดท้ายก็มีแนวโน้มสูงว่าจะต้องใช้โมเดลแบบนั้น
    คอขวดที่แท้จริงอาจเป็นความก้าวหน้าทะลุทะลวงในการฝึกเอง
    loss จาก backpropagation นั้นเรียบง่ายเกินไปแม้แต่สำหรับการเพิ่มประสิทธิภาพโมเดลปัจจุบันให้สมบูรณ์แบบ และยิ่งไม่พอสำหรับโมเดลที่ใหญ่กว่าในอนาคต
    ไม่มีอะไรรับประกันว่ามีทางเลือกที่ดีกว่าอยู่จริง ดังนั้นแนวทางแมชชีนเลิร์นนิงปัจจุบันอาจมีขีดจำกัดตายตัวก็ได้

• การที่การถกเถียงกระจัดกระจายอยู่หลายที่เป็นทั้งข้อดีและข้อเสีย
  ข้อความของ François Chollet ที่เห็นบน Twitter/X น่าสนใจ: https://x.com/fchollet/status/1841902521717293273
  “งานที่น่าสนใจในการชุบชีวิต RNN https://arxiv.org/abs/2410.01201 — โดยทั่วไปแล้ว การที่สถาปัตยกรรมล่าสุดที่มาจากคนละทิศทางมีประสิทธิภาพพอ ๆ กับ Transformer โดยประมาณ เป็นหลักฐานว่าในพาราไดม์การ fit เส้นโค้ง หรือก็คือใน deep learning นั้น สถาปัตยกรรมไม่ได้สำคัญในระดับพื้นฐาน
  การ fit เส้นโค้งคือการฝัง dataset ลงบนเส้นโค้ง ปัจจัยหลักคือ dataset ไม่ใช่การตกแต่งแบบ hard-code เฉพาะบางอย่างที่จำกัดรูปร่างของเส้นโค้ง ถ้าเส้นโค้งมีพลังในการแสดงออกเพียงพอ ในสภาพแวดล้อมที่มีข้อมูลขนาดใหญ่ สถาปัตยกรรมทั้งหมดจะลู่เข้าไปสู่ประสิทธิภาพเดียวกัน”

  • ผมแทบจะไม่เห็นด้วยกับคำพูดที่ว่า “ปัจจัยหลักคือ dataset ไม่ใช่การตกแต่งแบบ hard-code เฉพาะบางอย่างที่จำกัดรูปร่างของเส้นโค้ง”
    dataset มีอยู่มากมายมานานแล้ว และความก้าวหน้าในช่วง 10 ปีที่ผ่านมามาจากวิธีออกแบบเส้นโค้ง วิธี fit มันกับข้อมูล และวิธีใช้การคำนวณที่มากขึ้น
    ในเชิงทฤษฎีอาจพูดได้ว่าโมเดลเก่า ๆ ถ้าใช้การคำนวณมากขึ้นสักประมาณ 1 ล้านเท่าก็อาจแก้ปัญหาใหม่ ๆ ได้เหมือนกัน แต่การเรียกสิ่งนั้นว่า “ก็แค่ optimization” ก็คล้ายกับการมองข้ามความสำคัญของ การวิเคราะห์ความซับซ้อน ในการออกแบบอัลกอริทึม แล้วบอกว่า bogosort กับ quicksort เหมือนกัน
    ถ้าคิดถึงการใส่เทคนิค regularization หลายชั้นเพื่อลด overfitting รวมถึงโครงสร้างที่มีลักษณะเป็น agent มากขึ้นอย่าง Deep Q Learning หรือการออกแบบ search space ของ OpenAI o1 มุมมองที่ว่าเป็นแค่ optimization ธรรมดาก็ไม่น่าเชื่อถือเท่าไร
    การคำนวณที่มากขึ้นอย่างเดียวไม่ได้ทำให้สถาปัตยกรรมเก่า ๆ แก้ปัญหาเหล่านั้นได้
  • ผมยังไม่ได้อ่าน paper ทั้งหมด แต่ดูเหมือนจะเน้นที่ การปรับประสิทธิภาพการคำนวณ มากกว่าขนาด dataset
    มีเนื้อหาอย่าง “parallelize ได้สมบูรณ์ระหว่างการฝึก และเร็วขึ้น 175 เท่าใน sequence ความยาว 512”
    ต่อให้หลายสถาปัตยกรรมลู่เข้าไปสู่ loss เดียวกันเมื่อเวลาผ่านไป การหาสถาปัตยกรรมที่ลู่เข้าเร็วที่สุดก็ยังมีคุณค่าพอสมควรเมื่อคิดถึงต้นทุน GPU ขนาดใหญ่
  • หนึ่งในบทบาทใหญ่ของการตกแต่งหลาย ๆ อย่างคือการ จำกัดพื้นที่การฝึก
    เหตุผลที่ CNN ครอง computer vision ไม่ใช่เพราะมันทำสิ่งที่ dense neural network ทำไม่ได้ แต่เพราะมันตัดการเชื่อมต่อจำนวนมากที่ไม่ค่อยสำคัญออกไป ทำให้ใช้งบประมาณการฝึกกับ network ที่ลึกขึ้นได้
    ในทำนองเดียวกัน เหตุผลที่ Transformer ยอดเยี่ยมคือมันช่วยให้ฝึก network ขนาดใหญ่ได้อย่างมีประสิทธิภาพในระดับหนึ่ง
    paper นี้ก็แสดงให้เห็นว่า ถ้าทำให้การฝึก RNN เร็วขึ้นมาก ๆ มันก็ดีทีเดียวในทางปฏิบัติ
    คอขวดใหญ่คือ ความเร็วและประสิทธิภาพในการฝึก มากกว่าพลังในการแสดงออกจริงของสถาปัตยกรรม
  • ถ้าคิดว่า MLP เป็น universal function approximator ก็ดูค่อนข้างเป็นเรื่องที่คาดได้
    MLP ขนาดมหึมาก็สามารถให้ผลลัพธ์แบบเดียวกับ Transformer ได้
    ปัญหาคือเรื่อง scale และอยู่ตรงที่เราไม่สามารถฝึก MLP ที่ใหญ่พอได้
    Transformer มีประโยชน์เพราะเป็นการ optimize ด้านประสิทธิภาพ
  • ท้ายที่สุดแก่นหลักน่าจะเป็น ประสิทธิภาพการคำนวณ
    เราไม่ได้อยาก retrain เดือนละครั้ง แต่อยาก retrain อย่างต่อเนื่อง และไม่ได้อยากให้ agent หนึ่งตัวคุยกับ LLM 5 ตัว แต่อยากให้ LLM หลายพันตัวทำงานร่วมกัน

• คำตอบดูเหมือนจะใกล้เคียงกับ “ไม่ใช่”
  RNN แบบนี้อาจดีพอในบางกรณี และอาจชนะ Transformer ได้ในบางกรณี แต่คงไม่สามารถแทนที่ Transformer ใน LLM ได้โดยทั่วไป
  ตัวอย่างเช่น ถ้าผู้ใช้ให้ข้อความยาว ๆ แล้วบอกว่า “แปลสิ่งนี้เป็นภาษาเยอรมันให้หน่อย” Transformer สามารถย้อนกลับไปดูประวัติทั้งหมดได้
  แม้ RNN จะมีความยาวบริบทไม่จำกัด แต่ปริมาณข้อมูลที่มันจดจำได้ในช่วงเวลาใด ๆ ก็ถูกจำกัดอยู่ภายใน hidden state
  paper ที่เกี่ยวข้อง: https://arxiv.org/abs/2402.01032

  • เรื่องที่ว่า “ปริมาณข้อมูลที่จดจำได้ถูกจำกัดอยู่ใน hidden state” นั้น Transformer ก็ไม่ได้ต่างกัน
    ท้ายที่สุด Transformer ก็ถูกผูกไว้กับสถานะจำกัดเช่นกัน เพียงแต่สถานะนั้นถูกจัดระเบียบในอีกแบบหนึ่งเท่านั้น
  • ปัญหานั้นรบกวน RNN มาตั้งแต่ยุค 90 แล้ว
    มี ปัญหาความละเอียดของข้อมูล ว่าสถานะเก่าต้องส่งผ่านกี่บิต ปัญหาการเสื่อมถอยที่ข้อมูลยิ่งเก่ายิ่งอ่อนลง และปัญหาการปะปนที่ representation ถูกผสมหรือบวกทับกัน
  • ข้อโต้แย้งคือ ถ้าเพิ่มขนาด hidden state ให้ใหญ่พอ ก็สามารถใส่ compressed representation ของ sequence ที่มีความยาวตามต้องการได้
    สิ่งที่อยากรู้คือ เมื่อกำหนดจำนวน floating-point operations ไว้คงที่ RNN จะแข่งขันกับ Transformer ได้หรือไม่ แต่ paper ต้นฉบับดูเหมือนไม่ได้แตะประเด็นนี้อย่างจริงจัง
  • ไม่จำเป็นต้องเขียนท้ายบทความยาว ๆ ว่า “แปลเป็นภาษาเยอรมันให้หน่อย”
    แต่ให้เขียนว่า “แปลข้อความต่อไปนี้เป็นภาษาเยอรมันให้หน่อย” แทน เท่านี้สิ่งที่ต้องจำก็มีแค่งานปัจจุบันกับอินพุตล่าสุดในปริมาณที่น้อยกว่ามาก
    แน่นอนว่าต้องมีความสามารถในการสร้างเอาต์พุตแบบขนานระหว่างประมวลผลอินพุตด้วย

• เท่าที่ผมเข้าใจ เหตุผลที่ Transformer ทำให้บูมในภายหลังเป็นไปได้ คือมันแก้ปัญหาใหญ่สองอย่างของ RNN ได้
  การหายไปของเกรเดียนต์ จำกัดทั้งบริบทและขนาดโมเดล และการทำ parallelization ได้ยากก็จำกัดขนาดข้อมูลฝึก
  ตอนนี้เลยสงสัยว่ามีวิธีแก้สองปัญหานี้แล้วหรือยัง

  • Transformer สามารถดึงข้อมูลก่อนหน้าที่มีประโยชน์ในภายหลังกลับมาใช้ได้ไม่ว่าที่จุดใด
    RNN ต้องอัปเดตและเขียนทับหน่วยความจำไปเรื่อย ๆ จึงต้องคาดการณ์ล่วงหน้าแล้วเก็บข้อมูลที่อาจมีประโยชน์ภายหลังไว้
    ใน กรณีใช้งานแบบสนทนา อย่าง ChatGPT นี่เป็นข้อได้เปรียบมหาศาลของ Transformer
    เมื่อให้บริบทแล้วถามต่อเนื่องหลายเทิร์น เราจะรู้ว่าบริบทใดสำคัญต่อคำถามหนึ่ง ๆ ก็ต่อเมื่อไปถึงช่วงท้ายของลำดับโทเคนแล้ว
    พูดให้แม่นยำกว่านั้นควรเรียกว่าเป็นข้อดีของโมเดลแบบอิง attention และก็มีโมเดลไฮบริดอย่าง Jamba ที่ผสมสองแนวทางนี้ได้สำเร็จด้วย
  • การหายไปหรือระเบิดของเกรเดียนต์ไม่ได้กระทบแค่ RNN แต่กระทบโครงสร้างเชิงลึกทั้งหมด
    LSTM ที่เสนอครั้งแรกในปี 1997 เป็นตัวที่เสนอทางแก้ก่อน: https://www.semanticscholar.org/paper/Long-Short-Term-Memory...
    น่าสนใจที่ความรู้นี้ดูเหมือนแทบถูกลืมไปแล้ว
    ราวปี 2014 LSTM เคยได้รับความนิยมมาก: https://karpathy.github.io/2015/05/21/rnn-effectiveness/
    https://colah.github.io/posts/2015-08-Understanding-LSTMs/
  • จากที่อ่าน论文คร่าว ๆ บทความนี้มุ่งเป้าไปที่ parallelization และการฝึกที่เร็วขึ้น มากกว่า “การหายไปของเกรเดียนต์”
    อย่างไรก็ดี ดูเหมือนว่าการทำให้หน่วยวนซ้ำเรียบง่ายลงจะช่วยปรับปรุงทั้งสองเรื่อง
    เป็นงานที่ค่อนข้างฉลาดและน่าสนใจ
    บทความเรียกมันซ้ำ ๆ ว่า “สถาปัตยกรรมอายุ 10 ปี” แต่จริง ๆ แล้วมันยังถูกใช้มหาศาลในปัจจุบัน เพราะปรับให้เข้ากับหลายโดเมนได้ง่าย
    การวางมันเป็น “คู่แข่ง” ของ Transformer ก็ไม่ยุติธรรมเต็มที่นัก เพราะ Transformer กับ RNN ไม่ได้排互กัน และมีหลายวิธีที่จะรวมทั้งสองเข้าด้วยกัน
    การปรับปรุง RNN อาจนำไปสู่การปรับปรุงในหลายที่ที่คาดไม่ถึงได้

• ชอบความเรียบง่ายของโครงสร้าง minGRU มาก
  โดยพื้นฐานคือสร้างสถานะซ่อนที่เสนอและค่าสัมประสิทธิ์การผสมจาก token ด้วยการแปลงเชิงเส้นแยกกัน แล้วผสมด้วย torch.lerp(proposed_hidden_state, previous_hidden_state, mix_factors)
  เนื่องจากสถานะซ่อนที่เสนอและค่าสัมประสิทธิ์การผสมของแต่ละชั้นขึ้นกับโทเคนปัจจุบันเท่านั้น ถ้ารู้ทั้งลำดับล่วงหน้าเหมือนตอนฝึก ก็สามารถคำนวณทั้งหมดแบบขนานก่อน แล้วรวมกันในเวลาเชิงเส้นด้วย parallel scan ได้
  การที่สิ่งนี้แข่งขันกับ Transformer และ state space model ได้ในการทดลองขนาดเล็ก ตอบโจทย์ความรู้สึกของคนที่เชื่อว่า “PR ที่ดีที่สุดคือ PR ที่ลบโค้ด”
  ถึงอย่างนั้น จนกว่าจะลองขยายให้มีสเกลพารามิเตอร์และข้อมูลใกล้เคียงกับโมเดลระดับแนวหน้าล่าสุด ก็ยังบอกไม่ได้ว่านี่เป็น Breakthrough ตัว B ใหญ่หรือไม่
  ดูจากภาคผนวก เหมือนว่าการคำนวณทั้งหมดทำใน log space ซึ่งบอกว่าเป็นเพราะเสถียรภาพเชิงตัวเลข
  ยังจับสัญชาตญาณไม่ค่อยได้ว่าเป็นเพราะถ้าเอา tanh ออกจากเอาต์พุตแล้วคำนวณในพื้นที่เชิงเส้น ค่าจะพุ่งระเบิดได้หรือเปล่า
  อีกอย่าง แค่ข้อเท็จจริงที่ว่า sequence modeling แบบนี้ทำงานได้เองก็น่าสนใจแล้ว
  ให้ความรู้สึกเหมือนฉีกทุกหน้าของหนังสือแล้วส่งให้แบบสุ่มลำดับ จากนั้นให้สร้างเวกเตอร์ของแต่ละหน้าและ “วิธีผสมเวกเตอร์นี้กับเวกเตอร์รวมของหน้าก่อนหน้าทั้งหมด” โดยไม่รู้หน้าก่อนหน้าเลย แล้วผมเอากลับมาผสมตามลำดับจริงและให้คะแนนว่าเวกเตอร์สุดท้ายสรุปหนังสือทั้งเล่มได้ดีแค่ไหน
  ตอนนี้ใช้แค่ dense linear layer สองชั้นในการแปลงโทเคนเป็นสถานะซ่อนที่เสนอและค่าสัมประสิทธิ์ผสมสำหรับการอินเตอร์โพเลต เลยสงสัยด้วยว่าจะเป็นอย่างไรถ้าทำการแปลงนี้เป็น MLP แทน linear layer เดี่ยว

  • มองเผิน ๆ โครงสร้างนี้ดูเหมือนจะปิดกั้นความสามารถพื้นฐานในการรู้จำลำดับโทเคน
    อย่างน้อยก็น่าจะเกิดปัญหาแบบ pumping lemma
    ถ้า [the ][cat ][is ][black ] สร้างเอาต์พุตที่ใกล้กับเวกเตอร์หนึ่ง อินพุตที่ทำซ้ำ [the ][cat ][is ][black ] สามครั้งก็น่าจะยิ่งเข้าใกล้เวกเตอร์นั้นมากขึ้น และไกลจากเวกเตอร์ที่บอกว่า “ทำไมประโยคเดียวกันถึงซ้ำสามครั้ง?” ไม่ใช่หรือ
    ถ้าไม่มีการผสมแบบไม่เชิงเส้นระหว่างโทเคนอินพุตกับสถานะซ่อน ก็น่าจะเหลือความคล้ายเชิงเส้นระหว่างลำดับโทเคนที่คล้ายกันอยู่มาก
  • ผมไม่คิดว่านี่เป็น Breakthrough ตัว B ใหญ่ แต่โครงข่ายประสาทแบบวนซ้ำมีอยู่ทุกหนแห่ง
    ถ้าเป็นการทำให้ง่ายขึ้นที่ช่วยปรับปรุงการฝึกและประสิทธิภาพ ก็จะสร้างเวทีให้เติมความซับซ้อนกลับเข้าไปในระดับที่สูงขึ้นได้
  • log space สำคัญเมื่อความน่าจะเป็นของโทเคนมีช่วงค่ากว้างมาก หรือแตกต่างกันหลายหลัก
    มีเหตุผลที่การฟิตแบบ maximum likelihood มักทำในรูป log likelihood เสมอ

• ผมเคยทำ RNN เป็นโปรเจกต์มหาวิทยาลัย ตอนนั้นสนใจเทคโนโลยีประวัติศาสตร์ที่หายไปแล้ว เลยคิดว่าหลังออกจากโรงเรียนคงไม่ได้ยินเรื่องโครงข่ายประสาทอีก จึงต้องคว้าโอกาสไว้
  สิ่งที่ทำขึ้นมานั้นทำงานได้ แต่เรียบง่ายมากและช้ามหาศาลบนแล็ปท็อปเก่า ๆ
  บนแล็ปท็อปเครื่องนั้นไม่มีอะไรเร็วได้อยู่แล้ว แต่ผมจำได้ว่า RNN ช้ากว่า feedforward network อย่างมาก
  ตอนนั้นมั่นใจว่านี่คือ เทคโนโลยีที่ตายแล้ว เป็นของเล่นทางวิชาการในยุค 1980–1990 แต่พอเห็นว่ามันเปลี่ยนไปเร็วแค่ไหน ก็รู้สึกแปลกมาก

  • รู้สึกแก่ขึ้นมาเลย
    ราวปี 2000 ผมเขียนวิทยานิพนธ์ปริญญาโทเกี่ยวกับการเรียนรู้ระบบไดนามิก เช่น RNN เพื่อวัตถุประสงค์ด้านการควบคุม ซึ่งตอนนั้นถือว่าเป็นหัวข้อค่อนข้างใหม่
    ผมเขียน backpropagation ด้วย C++ แล้วปล่อยให้รันข้ามคืน และมันช้ามากเพราะเกรเดียนต์เล็ก
    โครงสร้างเครือข่ายก็เป็นแค่ชั้นซ่อนเดี่ยวที่มีนิวรอนประมาณ 5 หรือ 10 ตัว
    โครงข่ายประสาทเคยเป็นหัวข้อเล็ก ๆ ที่ถ้าหาคอร์สเรียนได้ก็ถือว่าโชคดี แต่พอหลับตาแป๊บเดียวแล้วกลับมาดูอีกทีในปี 2015 ทุกอย่างก็เปลี่ยนไปโดยสิ้นเชิง

• ผู้เขียน ซึ่งรวมถึง Yoshua Bengio ด้วยนั้น น่าชื่นชมตรงที่ไม่ได้เสนอราวกับว่าบทความวิจัยรู้คำตอบ แต่จบลงด้วยคำถาม
  โมเดลเหล่านี้มีขนาดเล็กมากแม้ตามมาตรฐานงานวิชาการ ดังนั้นจึงไม่อาจถือได้ว่าผลลัพธ์ใด ๆ จะขยายไปถึงสเกลของ LLM ในปัจจุบันได้อย่างแน่นอน
  ข้อสรุปหลักคือเครือข่ายตระกูล RNN ก็สามารถฝึกได้อย่างมีประสิทธิภาพพอ ๆ กับทางเลือกสมัยใหม่ แต่ความสามารถในการแข่งขันของประสิทธิภาพผลลัพธ์นั้นยืนยันได้เฉพาะในระดับ ขนาดเล็ก เท่านั้น

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

• โมเดลในบทความวิจัยนี้ถูกทำให้ขนานกันได้ จึงไม่ใช่ RNN “แท้” ด้วยเหตุผลเดียวกับที่อธิบายใน https://arxiv.org/abs/2404.08819 และดังนั้นในเชิงทฤษฎีจึงมีพลังน้อยกว่า RNN แบบดั้งเดิม
  มันมีปัญหากับงานบางกลุ่มที่เดิมที RNN ทำได้ดี
  ในทางกลับกัน https://arxiv.org/abs/2405.04517 มีองค์ประกอบ RNN “แท้” อยู่ และแสดงให้เห็นการปรับปรุงอย่างมากใน ปัญหาการติดตามสถานะ ซึ่ง Transformer ทำได้ยาก

  • สิ่งเหล่านี้ก็เป็น RNN แท้เช่นกัน
    มันยังคงพึ่งพาสถานะซ่อนก่อนหน้า เพียงแต่เกตไม่ได้พึ่งพาเท่านั้น
    สมการ RNN พื้นฐานสามารถทำให้ขนานกันได้ด้วย อัลกอริทึม parallel prefix scan

• ผมยังไม่ได้ดูบทความวิจัยอย่างละเอียดนัก แต่ถ้ามีใครช่วยตอบได้ก็คงดี
  อย่างที่บอก ถ้าเอา สถานะซ่อน ออกจาก RNN แล้วจะเหลืออะไร? เป็น MLP ที่ทำนายจากโทเคนเดียวหรือเปล่า?

  • ไม่ได้เอาสถานะซ่อนออกไปทั้งหมด แต่เอาออกเฉพาะจาก input gate, forget gate และ update gate เท่านั้น
    ผมยังไม่ได้ย่อยบทความวิจัยนี้จนหมด แต่ในกรณีของ GRU ดูเหมือนจะหมายถึงการ masking การอัปเดตสถานะซ่อน กล่าวคือ z_t และ r_t ในสมการของบทความวิจัยขึ้นอยู่กับอินพุตใหม่เท่านั้น ไม่ได้ขึ้นอยู่กับผลรวมของอินพุตกับสถานะซ่อนก่อนหน้า
  • ไม่ได้เอาออกทั้งหมด แต่เอาเฉพาะ dependency บางอย่างออก เพื่อให้คำนวณได้ด้วย parallel scan
    มันยังคงมีสถานะซ่อนอยู่
    ค่อนข้างคล้ายกับสิ่งที่ทำใน Mamba
  • จากที่กวาดตาดูคร่าว ๆ ดูเหมือนจะปรับการอัปเดตสถานะเพื่อให้รันด้วย parallel scan ได้ โดยไม่ต้องรันแบบลำดับต่อเนื่อง
  • เคล็ดลับคือทำให้ dependency แบบ recursive คงความเป็น เชิงเส้น ไว้ จึงทำให้ฝึกแบบขนานได้