ฉันจะอธิบายวิธีการสร้างโมเดลอัลฟาหลายปัจจัยระดับกองทุนเฮดจ์ฟันด์โดยใช้กราฟเอ็นจิเนียริ่ง
มาเริ่มกันเลย
บุ๊กมาร์กไว้นะ
- ผมคือโรนัน นักพัฒนาแบ็กเอนด์ที่ทำงานด้านการออกแบบระบบ การเทรดแบบ HFT และระบบเทรดเชิงปริมาณ ผลงานของผมเน้นไปที่พฤติกรรมของตลาดพยากรณ์ภายใต้โหลดสูง สามารถส่งข้อความมาเพื่อแนะนำหรือร่วมงานกันได้
ในบทความก่อนหน้านี้ ผมบอกว่าจะแนะนำการตั้งค่าครั้งแรก 20 ครั้งให้กับใครก็ตามที่กำลังสร้างระบบ AI เชิงปริมาณ และผมก็ตั้งใจทำจริงๆ
มีนักพัฒนาบางส่วนที่กำลังดำเนินการลึกกับผมแล้ว ข้อเสนอยังคงเปิดอยู่
ถ้าคุณกำลังสร้างระบบกราฟเอ็นจิเนียริ่ง หรือกำลังจะเริ่ม หรือแค่คิดจะทำ ก็ตอบกลับใต้บทความนี้หรือส่งข้อความบอกการตั้งค่าปัจจุบันของคุณ ผมจะแนะนำสถาปัตยกรรมของคุณให้คุณเห็นถึงช่องว่างระหว่างสิ่งที่คุณมีกับฝูงที่ล่าอัลฟาได้ด้วยตัวเอง
ถ้าผมไม่ตอบกลับ แสดงว่าคุณไม่ได้อยู่ใน 20 คนแรก รีบหน่อย
การลงทุนแบบหลายปัจจัยคือวิธีที่กองทุนเฮดจ์ฟันด์ชั้นนำบนวอลล์สตรีทสร้างผลตอบแทน พวกเขาไม่ได้เทรดแค่ไอเดียเดียว พวกเขาซ้อนปัจจัยหลายอย่าง
นี่คือกระบวนการเดียวกับที่ AQR, Two Sigma, และ Bridgewater ใช้ และนี่เป็นครั้งแรกที่นักพัฒนาคนเดียวสามารถทำได้
ปัญหาที่ผ่านมาคือการสร้างสิ่งนี้ต้องใช้ทีมวิจัย วิศวกรปัจจัย นักสถิติ ผู้เชี่ยวชาญด้านการสร้างพอร์ต นักวิเคราะห์ความเสี่ยง วิศวกรการเทรด คุณต้องการอย่างน้อยสิบคนต่อหนึ่งตระกูลปัจจัย และนักเทรดเชิงปริมาณคนเดียวไม่สามารถสร้างทีมแบบนั้นได้
นั่นคือเหตุผลที่นักเทรดเชิงปริมาณรายย่อยติดอยู่กับกลยุทธ์เดียว ในขณะที่กองทุนเฮดจ์ฟันด์พิมพ์อัลฟาได้
จนถึงตอนนี้
https://x.com/RohOnChain/status/2074134246784921977
ในสองบทความล่าสุด ผมได้แนะนำ ลูปเอ็นจิเนียริ่ง และวิธีสร้าง ฝูง AI Agent ที่ล่าอัลฟา 24/7
เมื่อคุณมีลูปและฝูงแล้ว ชั้นที่เชื่อมโยงพวกมันเข้าด้วยกันเป็นระบบที่ทำงานได้คือกราฟ
กราฟเอ็นจิเนียริ่งคือการออกแบบชั้นนั้น คุณกำหนดโหนด คุณกำหนดขอบ กราฟทำงานเอง
เมื่อจบบทความนี้ คุณจะไม่เพียงแค่เข้าใจกราฟเอ็นจิเนียริ่ง
คุณจะมีโมเดลอัลฟาหลายปัจจัยที่ทำงานเองทุก 24 ชั่วโมงบนแล็ปท็อปของคุณ
ส่วนที่ 1: กราฟเอ็นจิเนียริ่งคืออะไรจริงๆ
นักเทรดเชิงปริมาณทุกคนที่ทำงานกับ AI อยู่ในเส้นทางเดียวกัน การรู้ว่าคุณอยู่ตรงไหนจะทำให้ชัดเจนว่าต้องไปต่อยังไง
กราฟเอ็นจิเนียริ่งคืออะไรจริงๆ
ขั้นที่ 1: โพรอมต์
คุณพิมพ์โพรอมต์ คุณรอ คุณอ่านผลลัพธ์ คุณพิมพ์อันถัดไป คุณคือลูป ทุกอย่างหยุดเมื่อคุณปิดแล็ปท็อป
ขั้นที่ 2: ลูป
คุณเขียนสคริปต์ที่ครอบโพรอมต์และเรียกใช้ตามกำหนดเวลา ลูปเก็บสถานะ มันทำงานต่อหลังจากคุณปิดแล็ปท็อป นี่คือสิ่งที่บทความลูปเอ็นจิเนียริ่งของผมสอน เอเจนต์หนึ่งตัว งานหนึ่งชิ้น ทำงานตลอดไป
ขั้นที่ 3: ฝูง
คุณขยายลูปออกเป็นเอเจนต์หลายตัวที่มีบทบาทเฉพาะ ตัวหนึ่งสร้างสัญญาณ ตัวหนึ่งตรวจสอบ ตัวหนึ่งเทรด นี่คือสิ่งที่บทความฝูง AI Agent สอน เอเจนต์หลายตัวแบบขนาน ประสานงานด้วยมือผ่านโค้ด Python กาว
ขั้นที่ 4: กราฟ
คุณอธิบายโครงสร้างการประสานงานครั้งเดียว โหนดคือเอเจนต์ ขอบคือการส่งต่อข้อมูล กราฟรู้ว่าเมื่อไหร่ควรทำแบบขนาน เมื่อไหร่ควรรอ เมื่อไหร่ควรลองใหม่ เมื่อไหร่ควรยกระดับ คุณไม่ต้องแตะโค้ดกาวอีก
กราฟเอ็นจิเนียริ่งคือการออกแบบโครงสร้างการประสานงานนั้น
กราฟไม่ใช่สคริปต์ ความแตกต่างนั้นสำคัญกว่าที่ใครๆ บอกคุณ
สคริปต์พังทันทีที่เอเจนต์ตัวหนึ่งต้องรออีกตัว สคริปต์พังทันทีที่สถานะต้องคงอยู่ข้ามรอบ สคริปต์พังทันทีที่คุณต้องการหกลูปแบบขนานในโมเดลต่างๆ นักเทรดเชิงปริมาณรายย่อยทุกคนที่พยายามสร้างระบบหลายเอเจนต์เคยเจอสามกำแพงนี้
กำแพงความล้มเหลวทำให้ผมเลิกเล่น เมื่อเอเจนต์ความสามารถในการทำกำไรของผมถูกบล็อกเพราะต้องแยกงบดุล 500 ตัวและถึงขีดจำกัดอัตรา ท่อส่งทั้งหมดก็ตาย
เช้าวันรุ่งขึ้นผมกลับมาที่กระบวนการที่หยุดทำงาน ไม่มีสัญญาณ และไม่รู้ว่าความล้มเหลวเริ่มต้นที่ไหน การดีบักหมายถึงการอ่านรอยแยกและเดาว่าเอเจนต์ตัวไหนอยู่ต้นทางของความล้มเหลว
ภายในเดือนที่สอง ผมใช้เวลาดีบักการประสานงานมากกว่าทำวิจัย ผมกำลังจะเก็บโปรเจกต์ทั้งหมด
นั่นคือสถานะล้มเหลวที่นักเทรดเชิงปริมาณหลายเอเจนต์ทุกคนเจอ และนั่นคือเหตุผลที่กราฟมีอยู่
กราฟไม่มีโหมดล้มเหลวเหล่านั้น การทำงานแบบขนานเป็นธรรมชาติ สถานะคงอยู่ถาวร ความล้มเหลวถูกจำกัดที่โหนด ไม่ใช่ท่อส่งทั้งหมด เมื่อโหนดหนึ่งเสีย กราฟที่เหลือยังทำงานต่อไป และคุณแก้ไขโหนดที่เสียโดยอธิบายความล้มเหลวเป็นภาษาอังกฤษธรรมดา
นั่นคือคำสัญญาของกราฟเอ็นจิเนียริ่ง ตอนนี้คำถามคืออะไรเป็นตัวรันกราฟ
ส่วนที่ 2: เครื่องมือที่รันกราฟ
กราฟคือแผนภาพสถาปัตยกรรม พวกมันไม่รันตัวเอง พวกมันต้องการรันไทม์
รันไทม์คือสิ่งที่คนส่วนใหญ่ที่สร้างระบบหลายเอเจนต์ทำผิด
พวกเขาคิดว่าส่วนที่ยากคือการออกแบบกราฟ มันไม่ใช่ ส่วนที่ยากคือการหาโครงสร้างพื้นฐานที่สามารถรันมันได้จริง
ผมใช้เวลาหลายสัปดาห์ลองรันไทม์ต่างๆ ก่อนจะเจออันที่สามารถรันกราฟหลายปัจจัยแบบครบวงจร
อันที่ผมใช้เรียกว่า Slate สร้างโดย @wearerandomlabs รันในเทอร์มินัลของคุณ รับการสมัครสมาชิกโมเดลที่คุณมีอยู่แล้วและกระจายงานไปยังโมเดลเหล่านั้น
สิ่งที่สำคัญสำหรับบทความนี้คือความสามารถที่พวกเขาเพิ่งเปิดตัวที่เรียกว่า Programs Program คือกราฟที่เขียนด้วย JavaScript ที่ Slate รันให้คุณอย่างต่อเนื่อง
โพรอมต์รันครั้งเดียวแล้วหยุด Program ทำงานต่อไปจนกว่างานจะเสร็จ
คุณไม่ได้เขียน Program เพียงลำพัง คุณบอก Slate ว่าคุณต้องการอะไรเป็นภาษาอังกฤษธรรมดา Slate ร่างกราฟ
Slate แล้วนำเสนอไดอะแกรมให้คุณ คุณถามคำถามเกี่ยวกับไดอะแกรม คุณเปลี่ยนโหนด คุณปรับโมเดล เมื่อคุณพอใจแล้วถึงบอก Slate ให้บันทึกและรัน
ถ้ามันพัง คุณแชทกับ Slate เกี่ยวกับความล้มเหลว Slate แก้ไขกราฟ
คุณสามารถหา Slate ได้ที่ http://randomlabs.ai/rr ใช้งานได้แล้ววันนี้
วิธีที่ดีที่สุดในการสัมผัสกราฟเอ็นจิเนียริ่งก่อนที่คุณจะสร้างคือการรัน Program ตัวอย่างสองตัวที่มาพร้อมกับ Slate
พวกมันถูกเรียกว่า
/goal
และ
/deepresearch
.
/goal - กราฟที่รันจนกว่าจะเสร็จสมบูรณ์อย่างตรวจสอบได้
พิมพ์สิ่งนี้ใน Slate:
1/goal implement a Newey-West adjusted t-statistic function in Python and verify it matches the statsmodels implementation on ten random return series
Slate ไม่ได้ยิงโพรอมต์เดียวไปที่โมเดล มันสร้างกราฟขึ้นมา
**โหนดหนึ่งเขียนฟังก์ชัน อีกโหนดเขียนการทดสอบตรวจสอบ โหนดที่สามรันทั้งสอง โหนดที่สี่ให้คะแนนว่าผลลัพธ์ตรงกันหรือไม่**
ถ้าไม่ตรงกัน กราฟจะวนกลับมาพร้อมข้อมูลความไม่ตรงกันที่เฉพาะเจาะจงเป็นข้อเสนอแนะ มันจะทำต่อไปจนกว่าโมเดลผู้ให้คะแนนขนาดเล็กอีกตัวจะยืนยันว่าเป้าหมายสำเร็จ
นี่คือรูปแบบผู้สร้าง-ผู้ตรวจสอบในรันไทม์ ผู้สร้างไม่เคยให้คะแนนงานของตัวเอง
/deepresearch - กราฟที่ทำวิจัยแบบขนาน
ลองสิ่งนี้ใน Slate:
1/deepresearch what does the latest academic research say about the Fama-French five factor model out of sample performance in emerging markets from 2015 to 2026
กราฟที่สร้างขึ้นที่นี่แตกต่างจาก /goal
มันเป็นการกระจายงานวิจัยแบบขนาน
Slate ส่งเอเจนต์ผู้ทำงานหลายตัวพร้อมกัน แต่ละตัวรับผิดชอบมุมที่แตกต่างของคำถาม
ตัวหนึ่งอ่านบทความล่าสุด อีกตัวตรวจสอบ arXiv q-fin อีกตัวดึงข้อมูลจากคลังข้อมูล Kenneth French อีกตัวตรวจสอบการอ้างอิงข้าม
พวกมันทั้งหมดรายงานกลับไปยังผู้ประสานงานกลางที่สังเคราะห์ผลลัพธ์
เหตุผลที่ /deepresearch สำคัญสำหรับการสร้างนี้คือมันแสดงรูปแบบที่คุณต้องการสำหรับการสร้างปัจจัย
เอเจนต์ปัจจัยเจ็ดตัว แต่ละตัวรับผิดชอบปัจจัยที่แตกต่าง ทำงานแบบขนานทั้งหมด รายงานไปยังผู้ประสานงานกลาง
นั่นคือกราฟหลายปัจจัย ลบงานเฉพาะเชิงปริมาณ
ใช้เวลา 30 นาทีรัน /goal และ /deepresearch กับคำถามที่คุณสนใจจริงๆ นั่นคือวิธีที่สัญชาตญาณกราฟเอ็นจิเนียริ่งเกิดขึ้น
ส่วนที่ 3: กราฟอัลฟาหลายปัจจัย
การลงทุนแบบหลายปัจจัยแยกส่วนผลตอบแทนหุ้นออกเป็นตัวขับเคลื่อนเชิงระบบบวกกับส่วนที่เหลือ เวอร์ชันพื้นฐานคือโมเดลสามปัจจัย Fama-French ที่ตีพิมพ์ในปี 1993:
R_i คือผลตอบแทนของหุ้น i R_f คืออัตราปลอดความเสี่ยง R_m คือผลตอบแทนตลาด SMB คือพรีเมียมขนาด HML คือพรีเมียมมูลค่า
อัลฟา α คือสิ่งที่โมเดลอธิบายไม่ได้ ส่วนที่เหลือนั้นคือสิ่งที่คุณกำลังตามหา
Carhart เพิ่มโมเมนตัมในปี 1997 Fama และ French เพิ่มความสามารถในการทำกำไร (RMW) และการลงทุน (CMA) ในปี 2015
กองทุนเฮดจ์ฟันด์สมัยใหม่ใช้ปัจจัยเจ็ดตัว AQR, Two Sigma, Millennium, Bridgewater ต่างก็ใช้รูปแบบที่แตกต่างกัน นี่คือเจ็ดปัจจัยที่สำคัญในปี 2026
ปัจจัยที่ 1: Market Beta.
การถดถอยแบบหมุนเวียน 60 เดือนของผลตอบแทนส่วนเกินของหุ้นเทียบกับผลตอบแทนส่วนเกินของตลาด
ปัจจัยที่ 2: ขนาด (SMB).
หุ้นขนาดเล็ก outperforms หุ้นขนาดใหญ่เมื่อปรับตามความเสี่ยง
ปัจจัยที่ 3: มูลค่า (HML).
หุ้นที่มีอัตราส่วนราคาต่อมูลค่าทางบัญชีสูง outperforms หุ้นที่มีอัตราส่วนต่ำในระยะยาว
ปัจจัยที่ 4: โมเมนตัม (MOM).
ผู้ชนะ 12 เดือนล่าสุดยังคงชนะต่อไปอีก 3 ถึง 12 เดือน
ปัจจัยที่ 5: ความสามารถในการทำกำไร (RMW).
ผู้ดำเนินงานที่แข็งแกร่ง outperforms ผู้ดำเนินงานที่อ่อนแอ
ปัจจัยที่ 6: การลงทุน (CMA).
การเติบโตของสินทรัพย์แบบอนุรักษ์นิยม outperforms การขยายตัวเชิงรุก
ปัจจัยที่ 7: ความผันผวนต่ำ.
หุ้นที่มีความผันผวนต่ำให้ผลตอบแทนปรับตามความเสี่ยงสูงกว่าที่ทฤษฎีคาดการณ์
ทุกกองทุนใช้รูปแบบของสิ่งนี้ นักพัฒนาคนเดียวทำไม่ได้เพราะต้องใช้ทีมวิจัย
กราฟเอ็นจิเนียริ่งแก้ปัญหานั้น แต่ละปัจจัยกลายเป็นโหนด
นี่คือกราฟทั้งหมด สิบเอ็ดโหนด
โหนดสร้างปัจจัย (ทำงานแบบขนาน)
โหนด 1: เอเจนต์ Market Beta
รันการถดถอยแบบหมุนเวียน 60 เดือน ให้ค่าเบต้าสำหรับทุกหุ้น
โหนด 2: เอเจนต์ขนาด
จัดเรียงตามมูลค่าตลาด คำนวณส่วนต่างเล็ก-ใหญ่
โหนด 3: เอเจนต์มูลค่า
จัดเรียงตามอัตราส่วนราคาต่อมูลค่าทางบัญชี คำนวณส่วนต่างสูง-ต่ำ
โหนด 4: เอเจนต์โมเมนตัม
คำนวณโมเมนตัม 12 ลบ 1 เดือน สร้าง MOM จากส่วนต่างเดไซล์
โหนด 5: เอเจนต์ความสามารถในการทำกำไร
คำนวณความสามารถในการทำกำไรขั้นต้น สร้าง RMW
โหนด 6: เอเจนต์การลงทุน
คำนวณการเติบโตของสินทรัพย์รายปี สร้าง CMA
โหนด 7: เอเจนต์ความผันผวนต่ำ
คำนวณความผันผวนที่เกิดขึ้นจริง 60 วันย้อนหลัง สร้างความผันผวนต่ำจากส่วนต่างเดไซล์
โหนดประสานงาน (ทำงานตามลำดับ)
โหนด 8: ผู้ตรวจสอบ
รันสถิติ t ที่ปรับด้วย Newey-West สำหรับแต่ละปัจจัย สุ่มตัวอย่างแบบ Bootstrap 10,000 ครั้ง กำจัดปัจจัยใดๆ ที่ความเสื่อมของประสิทธิภาพในตัวอย่างเทียบกับนอกตัวอย่างสูงกว่า 30 เปอร์เซ็นต์
รันบนโมเดลเหตุผลที่แข็งแกร่งกว่า ผู้สร้างไม่เคยตรวจสอบงานของตัวเอง
โหนด 9: ผู้ตรวจสอบระบบ
แบ่งประวัติศาสตร์ 20 ปีออกเป็นสามระบบโดยใช้ Hidden Markov Model กับความผันผวนและผลตอบแทน กำจัดอะไรก็ตามที่ใช้ได้แค่ในระบบเดียว
โหนด 10: ผู้สร้างพอร์ต
รวมปัจจัยที่รอดชีวิตเป็นพอร์ตระยะยาว-ระยะสั้นโดยใช้น้ำหนักความเสี่ยงเท่ากัน บังคับใช้ความเป็นกลางทางภาคส่วน เบต้า และสกุลเงิน
โหนด 11: ผู้แยกส่วนความเสี่ยง
ถดถอยพอร์ตกับปัจจัยเจ็ดตัวบวกปัจจัยสไตล์และมหภาค รายงานอัลฟาส่วนที่เหลือและสถิติ t
เฉพาะสัญญาณที่อัลฟาส่วนที่เหลือรอดจากการแยกส่วนปัจจัยเท่านั้นที่เป็นอัลฟาใหม่จริง ที่เหลือคือสไตล์ที่ถูกบรรจุใหม่พร้อมขั้นตอนเพิ่มเติม
สิบเอ็ดโหนด แต่ละโหนดมีงานเดียว พวกมันส่งผ่านผลลัพธ์ลงกราฟ
โมเดลทั้งหมดรันบน Slate Program เดียวที่ทำงานทุก 24 ชั่วโมง
ส่วนที่ 4: วิธีสร้างทีละขั้นตอน
นี่คือการสร้างที่แน่นอน ทำตามในเทอร์มินัลของคุณ
ขั้นตอนที่ 1: ติดตั้ง Slate
เปิดเทอร์มินัลแล้วรัน:
1npm i -g @randomlabs/slate
Slate เป็นแพ็คเกจ npm ทั่วโลก การติดตั้งใช้เวลาประมาณ 30 วินาที
ตรวจสอบด้วย:
1slate --version
ขั้นตอนที่ 2: สร้างไดเรกทอรีโปรเจกต์ของคุณ
การวิจัยหลายปัจจัยต้องการพื้นที่ทำงานของตัวเอง ไฟล์สถานะ การทดสอบปัจจัยย้อนหลัง ภาพรวมพอร์ตทั้งหมดอยู่ที่นี่
1mkdir ~/projects/multifactor-alpha2cd ~/projects/multifactor-alpha
อย่ารันโปรเจกต์ Slate อื่นๆ จากโฟลเดอร์เดียวกัน การกำหนดเนมสเปซสถานะเป็นต่อพื้นที่ทำงาน
ขั้นตอนที่ 3: เปิดใช้งาน Slate
พิมพ์:
1slate
ขั้นตอนที่ 4: เชื่อมต่อผู้ให้บริการของคุณ
ใน Slate พิมพ์:
1/providers
นี่จะเปิดหน้าจอการตั้งค่าผู้ให้บริการ Random Labs จะรับรองความถูกต้องโดยค่าเริ่มต้น คุณยังสามารถเชื่อมต่อ OpenAI Codex และ GitHub Copilot ได้โดยตรง
นำทางไปยัง Codex ด้วยปุ่มลูกศรแล้วกด Enter เพื่อรับรองความถูกต้อง การสมัครสมาชิกที่มีอยู่ของคุณก็ใช้งานได้
ขั้นตอนที่ 5: เชื่อมต่อโมเดลของคุณ
ใน Slate พิมพ์:
1/models
คุณจะเห็นทุกโมเดลที่มีให้บริการจากทุกผู้ให้บริการที่เชื่อมต่อ Random Labs โฮสต์ประมาณ 90 โมเดล
คุณต้องการสองระดับโมเดล
ระดับเร็วสำหรับเอเจนต์สร้างปัจจัยเจ็ดตัว Claude Sonnet ใช้ได้
ระดับเหตุผลที่แข็งแกร่งกว่าสำหรับผู้ตรวจสอบ ผู้ตรวจสอบระบบ และผู้แยกส่วนความเสี่ยง Claude Opus ใช้ได้
ขั้นตอนที่ 6: อุ่นเครื่องด้วย /goal และ /deepresearch
ก่อนที่คุณจะร่าง Program ของคุณเอง ใช้เวลา 30 นาทีกับ Program ตัวอย่างสองตัวที่มาพร้อมกับเครื่อง
นี่คือวิธีที่กราฟเอ็นจิเนียริ่งหยุดเป็นแนวคิดและเริ่มเป็นสัญชาตญาณ
ลองคำสั่ง /goal นี้ใน Slate:
1/goal write a Python function that computes Fama-MacBeth cross sectional regression coefficients and verify it matches the empiricalfin package on 20 years of monthly return data
ดูว่ากราฟกระจายงานอย่างไร ดูโมเดลผู้ให้คะแนนตรวจสอบงานของโมเดลผู้เขียน ดูว่าเกิดอะไรขึ้นเมื่อความพยายามแรกล้มเหลว
จากนั้นลองคำสั่ง /deepresearch นี้:
1/deepresearch what does the academic literature say about the profitability factor RMW versus the quality factor as defined by MSCI and how do they differ empirically from 2015 to 2026
ดูการกระจายงานผู้ทำงานแบบขนาน ดูผู้ประสานงานสังเคราะห์
สองรันนี้ให้แบบจำลองทางความคิดที่คุณต้องการก่อนเขียน Program ของคุณเอง
ขั้นตอนที่ 7: ร่าง Program หลายปัจจัย
นี่คือขั้นตอนที่สำคัญที่สุด คุณอธิบายกราฟเป็นภาษาอังกฤษธรรมดาและ Slate ร่างมันร่วมกับคุณ
พิมพ์โพรอมต์นี้ลงใน Slate:
1draft me a program that runs seven multi-factor research agents in parallel:2market beta, size, value, momentum, profitability, investment, and low-volatility.3After all seven complete, run a validator, a regime auditor, a portfolio4constructor, and a risk decomposer in sequence. Use Claude Sonnet for the seven5factor agents and Claude Opus for validator, regime auditor, and risk decomposer.6Run the whole pipeline every 24 hours. Use file system as memory. Set a budget7of $30 per run. Enforce Newey-West t-stat above 2.5, bootstrap 10,000 iterations,8and reject any factor with in-sample versus out-of-sample Sharpe degradation9above 30 percent.
Slate ไม่ได้แค่เริ่มเขียนโค้ด มันอ่านอย่างละเอียดและถามคำถามเพื่อความชัดเจน
แหล่งข้อมูลไหน หน้าต่างทดสอบย้อนหลังอะไร จักรวาลไหน ตัวจำแนกระบบอะไร จะใช้ค่าเริ่มต้นที่แทนที่ได้หรือไม่
คุณตอบเป็นภาษาอังกฤษธรรมดา Slate เขียน JavaScript
ขั้นตอนที่ 8: ตรวจสอบไดอะแกรมกราฟ
เมื่อ Slate ร่าง Program เสร็จ มันจะแสดงไดอะแกรมของกราฟ
คุณไม่ได้อ่านโค้ดเพื่อเข้าใจว่าจะรันอะไร คุณกำลังดูโครงสร้างการประสานงาน
โหนดปัจจัยเจ็ดตัวรันแบบขนานจากผู้ประสานงาน จุดซิงค์ โหนดประสานงานสี่ตัวตามลำดับ ขั้นตอนการคงอยู่ โหนดพัก วนกลับไปด้านบน
ถามคำถาม Slate เกี่ยวกับไดอะแกรมก่อนรันอะไร:
- ทำไมผู้ตรวจสอบถึงรันบน Opus?
- จะเกิดอะไรขึ้นถ้าเอเจนต์โมเมนตัมหมดเวลา?
- สถานะอะไรที่ถูกคงอยู่ระหว่างรอบ?
- อะไรเป็นตัวกระตุ้นให้ผู้ตรวจสอบระบบปฏิเสธปัจจัย?
ถ้าคำตอบไหนทำให้คุณประหลาดใจ ให้บอก Slate ให้เปลี่ยนกราฟ
ขั้นตอนที่ 9: บันทึกและรัน
เมื่อไดอะแกรมตรงกับที่คุณต้องการ ให้บอก Slate ให้ commit Program ไปยังไฟล์ จากนั้นรัน:
1slate run multifactor-alpha.js
ทันทีที่คุณกด Enter Slate จะสร้างกราฟขึ้นมา เอเจนต์ปัจจัยเจ็ดตัวทำงานแบบขนาน
วิศวกรรมคุณลักษณะทำงานแบบขนาน การตรวจสอบทำงานบนโมเดลที่แข็งแกร่งกว่า
รันแรกใช้เวลา 15 ถึง 25 นาที รันรายวันครั้งต่อๆ ไปจะเร็วขึ้นเพราะไฟล์สถานะเก็บประวัติไว้แล้ว
ขั้นตอนที่ 10: ตั้งงบประมาณ
ใน Slate พิมพ์:
1/budget $30/run
นี่เป็นการจำกัดค่าใช้จ่ายทั้งหมดต่อรัน ถ้ารันใกล้ถึงขีดจำกัด Slate จะแจ้งเตือนก่อนดำเนินการต่อ
ขั้นตอนที่ 11: ดีบักเมื่อมันพัง
Program จริงพัง Program ของผมพังสามครั้งในสองสัปดาห์แรก
เอเจนต์มูลค่าถูกบล็อกเพราะไม่สามารถตีความงบดุลที่ไม่ใช่ของสหรัฐฯ ผมบอก Slate Slate แก้ไขเอเจนต์มูลค่าให้รวมขั้นตอนการปรับสกุลเงิน
เอเจนต์โมเมนตัมบางครั้งคืนสัญญาณที่รอดชีวิตเป็นศูนย์ในระบบที่ไม่เป็นมิตรกับโมเมนตัม ผมบอก Slate Slate เพิ่มตัวสำรองที่ขยายหน้าต่างมองย้อนหลังของโมเมนตัมในช่วงระบบเหล่านั้น
ผู้สร้างพอร์ตบางครั้งละเมิดความเป็นกลางทางภาคส่วน ผมบอก Slate Slate เพิ่มขั้นตอนการฉายภาพเพื่อบังคับใช้ความเป็นกลางก่อนเขียนพอร์ต
คุณไม่ต้องไล่รอยแยก คุณอธิบายปัญหาให้ Slate ฟัง Slate แก้ไขโหนด
ส่วนที่ 5: สิ่งที่เกิดขึ้นจริงเมื่อผมรันมัน
นี่คือส่วนที่ผมไม่ได้คาดหวัง
ผมอธิบายกราฟให้ Slate ฟังในหนึ่งย่อหน้า Slate ตรวจสอบตัวระบุโมเดลที่มีอยู่ก่อน เปิดใช้งานทักษะโมเดล และเลือก claude-sonnet-4.6 สำหรับเอเจนต์เร็วและ claude-opus-4.5 สำหรับขั้นตอนการประสานงาน
จากนั้น Slate ร่าง Program ทั้งหมดในครั้งเดียว ไม่ใช่ร่างคร่าวๆ JavaScript เต็มรูปแบบ สิบเอ็ดโหนดเชื่อมต่อกัน การสร้างปัจจัยแบบขนาน การตรวจสอบตามลำดับ หน่วยความจำที่ใช้ร่วมกันของระบบไฟล์พร้อมไดเรกทอรีรันที่มีประทับเวลา การจัดสรรงบประมาณ ทั้งหมด
Slate ไม่ได้แค่เขียนโค้ดแล้วหายไป มันกลับมาพร้อมกับการตัดสินใจเฉพาะสามข้อที่ต้องการให้ผมยืนยันก่อนที่เราจะรัน
การตัดสินใจที่ 1: โมเดลผู้สร้างพอร์ต โพรอมต์ร่างของผมระบุ Opus สำหรับผู้ตรวจสอบ ผู้ตรวจสอบระบบ และผู้แยกส่วนความเสี่ยง แต่ผมไม่ได้ระบุชื่อโมเดลสำหรับผู้สร้างพอร์ต Slate ตั้งค่าเริ่มต้นเป็น Opus เพราะขั้นตอนเป็นงานวิเคราะห์หนัก แต่แจ้งว่าสามารถเปลี่ยนได้ถ้าผมต้องการ Sonnet
การตัดสินใจที่ 2: เวอร์ชันโมเดล Slate ใช้ Sonnet และ Opus เสถียรปัจจุบัน (4.6 และ 4.5) และเสนอให้เปลี่ยนเป็นเวอร์ชันใหม่กว่าถ้าผมต้องการ
การตัดสินใจที่ 3: การบังคับใช้งบประมาณ อันนี้ทำให้ผมประหลาดใจ Slate บอกผมอย่างชัดเจนว่าขีดจำกัด $30 ต่อรันเป็นคำแนะนำ ไม่ใช่สวิตช์หยุดตายตัว ไม่มีหน่วยวัดต้นทุนแบบเรียลไทม์ ดังนั้นงบประมาณจึงถูกบังคับใช้เป็นขีดจำกัดที่ระบุบวกกับค่าใช้จ่ายที่รายงานเองซึ่งถูกรวมและแจ้งเตือน ถ้าผมต้องการหยุดกลางคันแบบแข็งกร้าว Slate เสนอให้ออกแบบอย่างชัดเจน
การแจ้งเตือนครั้งที่สามนั้นคือเหตุผลที่ผมเชื่อถือเครื่องมือนี้ เฟรมเวิร์กเอเจนต์ส่วนใหญ่จะแกล้งทำอย่างเงียบๆ ว่างบประมาณถูกบังคับใช้ Slate บอกผมอย่างชัดเจนว่าชั้นการบังคับใช้ระดับไหนที่มันสามารถให้ได้จริงๆ
ผมยืนยันค่าเริ่มต้นทั้งสาม เปลี่ยนชื่อ Program เป็น multifactor-research-pipeline และบอก Slate ให้ commit
จากนั้นผมกดรัน
เอเจนต์ปัจจัยเจ็ดตัวทำงานทันที แต่ละตัวปรากฏในเทอร์มินัลพร้อม ID เอเจนต์ย่อยและตัวจับเวลาสถานะของตัวเอง
Slate ยืนยันการรันเป็นภาษาอังกฤษธรรมดา:
"กำลังรันในพื้นหลังเป็น multifactor-pipeline เริ่มด้วยเอเจนต์ปัจจัยเจ็ดตัวแบบขนานบน Sonnet จากนั้นลำดับผู้ตรวจสอบ → ระบบ → พอร์ต → ความเสี่ยงบน Opus พร้อมค่าเริ่มต้น (./research-memory, งบประมาณ $30, สามเกต, ลูปตลอด 24 ชั่วโมง)"
บรรทัดเดียวนั้นจับได้ว่าทำไมกราฟถึงชนะสคริปต์
ผมไม่ได้เขียนโค้ดประสานงาน ผมไม่ได้ไล่รอยแยก ผมไม่ได้เชื่อมต่อ API เข้าด้วยกัน ผมอธิบายกราฟเป็นภาษาอังกฤษธรรมดา ตอบคำถามออกแบบสามข้อ และ Slate สร้างมัน
ทุกอย่างสามารถแทนที่ได้เมื่อเริ่มต้น ช่วงเวลา งบประมาณ เกณฑ์เกต โมเดล ตำแหน่งหน่วยความจำ และขีดจำกัด maxRuns ถ้าคุณไม่ต้องการให้กราฟรันตลอดไป
นี่คือ Program เต็มรูปแบบที่ Slate เขียนให้ผม ศึกษาแต่อย่าคัดลอกแบบคำต่อคำ ของคุณจะดูแตกต่างเล็กน้อยขึ้นอยู่กับคำตอบที่คุณให้กับคำถามเพื่อความชัดเจนของ Slate
ส่วนที่ 6: เกิดอะไรขึ้นทุก 24 ชั่วโมง
เวลา 3 นาฬิกาตามเวลาของคุณ กราฟตื่นขึ้น
เอเจนต์ปัจจัยเจ็ดตัวทำงานแบบขนาน แต่ละตัวดึงข้อมูลราคาและพื้นฐานล่าสุด 24 ชั่วโมง อัปเดตอนุกรมเวลาปัจจัย ส่งต่อไปยังผู้ตรวจสอบ
ผู้ตรวจสอบรันการทดสอบ t แบบ Newey-West สุ่มตัวอย่าง Bootstrap 10,000 ครั้ง กำจัดอะไรก็ตามที่ล้มเหลวนอกตัวอย่าง
ขั้นตอนนี้เพียงอย่างเดียวปฏิเสธประมาณ 80 เปอร์เซ็นต์ของสิ่งที่ดูมีแนวโน้มในการทดสอบย้อนหลังครั้งแรก
ผู้ตรวจสอบระบบรับสิ่งที่รอดชีวิต แบ่งประวัติศาสตร์โดยใช้ HMM คำนวณ Sharpe ใหม่ต่อระบบ
ปัจจัยที่ใช้ได้แค่ในระบบเดียวไม่ใช่อัลฟา มันคือเบต้าต่อระบบนั้น แต่งตัวเป็นอัลฟา
ผู้สร้างพอร์ตรับปัจจัยที่รอดชีวิต สร้างพอร์ตระยะยาว-ระยะสั้นโดยบังคับใช้ข้อจำกัดความเป็นกลาง
ผู้แยกส่วนความเสี่ยงรับพอร์ต ถดถอยกับชุดปัจจัยสไตล์และมหภาคกว้าง
ถ้าสถิติ t อัลฟาส่วนที่เหลือสูงกว่า 2.5 สัญญาณจะรอดชีวิต ถ้าไม่ วันนั้นจะถูกบันทึกว่าไม่มีสัญญาณและกราฟหลับจนถึงพรุ่งนี้
ทุกเช้าคุณตื่นขึ้นมาพบข้อความ Slack ไม่ว่าคุณจะมีสัญญาณที่สามารถเทรดได้ หรือคุณมีหลักฐานบันทึกว่าวันนี้เป็นเสียงรบกวน
ทั้งสองผลลัพธ์มีประโยชน์ ไม่มีข้อใดที่ต้องให้คุณอยู่หน้าคีย์บอร์ด
นี่คือลักษณะของโมเดลอัลฟาหลายปัจจัยที่ทำงานด้วยตัวเองในปี 2026
พิมพ์เขียว
ถ้าคุณจำอะไรไม่ได้อีกแล้ว ให้จำเจ็ดการเคลื่อนไหวนี้ตามลำดับ
1. เข้าใจความก้าวหน้า โพรอมต์กลายเป็นลูป ลูปกลายเป็นฝูง ฝูงกลายเป็นกราฟ
2. รู้จักปัจจัยของคุณ ตลาด, ขนาด, มูลค่า, โมเมนตัม, ความสามารถในการทำกำไร, การลงทุน, ความผันผวนต่ำ เจ็ดปัจจัย แต่ละปัจจัยกลายเป็นโหนดหนึ่ง
3. ออกแบบโหนดสิบเอ็ดโหนด เอเจนต์ปัจจัยเจ็ดตัวทำงานแบบขนาน เอเจนต์ประสานงานสี่ตัวทำงานตามลำดับ วาดกราฟก่อนที่คุณจะเขียนโค้ดแม้แต่บรรทัดเดียว
4. ใช้โมเดลที่แตกต่างกันสำหรับแต่ละโหนด ใช้ Sonnet สำหรับการสร้างปัจจัย ใช้ Opus สำหรับการตรวจสอบและการแยกส่วน ผู้สร้างไม่ควรตรวจสอบงานของตัวเอง
5. บังคับใช้กฎเกณฑ์ที่เข้มงวด ค่า t stat ของ Newey West ต้องมากกว่า 2.5 ทำ Bootstrap 10,000 ครั้ง ความทนทานของสภาวะตลาดครอบคลุมสามสถานะ HMM ค่า residual alpha t stat ต้องมากกว่า 2.5
6. วอร์มอัพด้วย /goal และ /deepresearch สัญชาตญาณทางวิศวกรรมกราฟเกิดจากการดูกราฟจริง ไม่ใช่จากการอ่านเกี่ยวกับมัน
7. ปล่อยให้มันทบต้น เดือนแรกคือการหา bugs เดือนที่สองคือการปรับแต่งปัจจัย พอถึงเดือนที่สาม กราฟของคุณจะสร้างสัญญาณที่คุณสามารถเทรดได้จริง
ลงมือสร้างเลย
ติดตั้ง Slate คืนนี้ เปิดใช้งานมัน รัน /goal กับคำถามเชิงปริมาณจริง รัน /deepresearch กับปัจจัยที่คุณอยากรู้
จากนั้นร่าง Program ของคุณเองโดยใช้ prompt ที่แน่นอนจากขั้นตอนที่ 6 ตรวจสอบแผนภาพ รันมัน ตั้งงบประมาณ $30
ภายในสัปดาห์หน้า คุณจะมีกราฟหลายปัจจัยที่ทำงานได้เองชุดแรก
ภายในเดือนหน้า คุณจะมีสัญญาณที่สามารถเทรดได้จริงซึ่งผ่านทั้งสิบเอ็ดโหนด
นั่นคือข้อแลกเปลี่ยน การตั้งค่าระบบหนึ่งสุดสัปดาห์เพื่อแลกกับระบบวิจัยแบบทบต้นที่ไม่เคยหลับใหล
ลงมือสร้างเลย
ถ้าคุณติดขัดตรงไหนระหว่างการสร้าง ส่ง DM มาหาผมได้ที่นี่
คุณสามารถหา Slate ได้ที่ http://randomlabs.ai/rr
ติดตาม @wearerandomlabs ถ้าคุณอยากเห็นทุกความสามารถที่พวกเขาปล่อยออกมา /goal และ /deepresearch เป็นสอง Programs แรก พวกเขาจะไม่ใช่ Programs สุดท้ายแน่นอน
