กระบวนการเกาส์เซียนสำหรับการสร้างแบบจำลองราคาแบบไม่อิงพารามิเตอร์

ส่วนหนึ่งของซีรีส์ "พื้นฐาน ML แบบคลาสสิก"

สองสิ่งที่ทำให้กระบวนการแบบเกาส์เซียนคุ้มค่ากับบทความแยกต่างหากในบล็อกนี้ และทั้งสองประการ "ไม่ได้ทำให้คุณมีความไม่แน่นอน"

อย่างแรกคือ การออกแบบเคอร์เนล อคติแบบอุปนัยทั้งหมดของ GP อาศัยอยู่ในฟังก์ชันเดียว $k(x, x')$และฟังก์ชันนั้นเป็นสิ่งที่คุณจงใจเขียน: เส้นทางนั้นหยาบแค่ไหน ไม่ว่าจะซ้ำหรือไม่ การซ้ำจะสลายหรือไม่ ไม่มีสิ่งใดในชุดเครื่องมือมาตรฐานที่ช่วยให้คุณสามารถระบุสมมติฐานเชิงโครงสร้างเกี่ยวกับการเปลี่ยนแปลงของตลาดได้อย่างชัดเจนและเหมาะสม ประการที่สองคือ ความเป็นไปได้เล็กน้อย — วัตถุประสงค์การฝึกอบรมที่มีการลดความซับซ้อนซึ่งได้มาจากตัวโมเดลเอง ไม่ใช่จากฉากที่ค้างไว้ บทความอื่นๆ ทุกบทความในส่วนโค้งที่มากเกินไปในบล็อกนี้ (การวิเคราะห์ที่ราบสูง, PBO, deflated Sharpe) มีอยู่เนื่องจากการทำให้เป็นมาตรฐานชุดการตรวจสอบความถูกต้องมีความเปราะบางภายใต้การค้นหา แพทย์ GP อ้างว่าไม่จำเป็นต้องใช้ คำกล่าวอ้างดังกล่าวสามารถทดสอบได้ และการทดสอบนั้นน่าสนใจมากกว่าบทช่วยสอนเรื่องการวัดขนาดที่ไม่แน่นอนอื่นๆ

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

สิ่งต่อไปนี้คือเคอร์เนลและกลไกการอนุมาน การใช้ GPyTorch และ — ระบุไว้อย่างชัดเจนในตอนท้าย — การวัดในบทความนี้ยังไม่มี

กระบวนการแบบเกาส์เซียนคืออะไร?

GP ปรากฏในบล็อกนี้แล้วในฐานะตัวแทนการเพิ่มประสิทธิภาพแบบเบย์ใน [Optuna เทียบกับพิกัดโคตร] (/th/blog/post/optuna-vs-coordinate-descent) โดยมีสัญกรณ์เดียวกันและข้อแม้มิติต่ำเหมือนกัน ในที่นี้ GP เป็นแบบจำลองของตัวเอง ซึ่งปรับให้เข้ากับข้อมูลการตลาดมากกว่าพื้นผิวการค้นหาไฮเปอร์พารามิเตอร์ ดังนั้นการรักษาจึงเจาะลึกยิ่งขึ้น

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

อย่างเป็นทางการฟังก์ชั่น $f: \mathcal{X} \to \mathbb{R}$ ถูกดึงมาจาก GP หากเป็นชุดอินพุตที่มีขอบเขตจำกัดใดๆ $\{x_1, x_2, \ldots, x_n\} \subset \mathcal{X}$:

$\begin{pmatrix} f(x_1) \\ f(x_2) \\ \vdots \\ f(x_n) \end{pmatrix} \sim \mathcal{N}\left(\begin{pmatrix} m(x_1) \\ m(x_2) \\ \vdots \\ m(x_n) \end{pmatrix}, \begin{pmatrix} k(x_1, x_1) & \cdots & k(x_1, x_n) \\ \vdots & \ddots & \vdots \\ k(x_n, x_1) & \cdots & k(x_n, x_n) \end{pmatrix}\right)$

ที่ไหน $m(x) = \mathbb{E}[f(x)]$ คือฟังก์ชันเฉลี่ยและ $k(x, x') = \text{Cov}(f(x), f(x'))$ คือฟังก์ชันความแปรปรวนร่วม (เคอร์เนล) เราเขียนสิ่งนี้ให้กระชับเป็น:

$f \sim \mathcal{GP}(m(\cdot), k(\cdot, \cdot))$

ฟังก์ชันค่าเฉลี่ยจะเข้ารหัสความเชื่อเดิมเกี่ยวกับพฤติกรรมโดยเฉลี่ยของ $f$. ในการซื้อขายเรามักจะตั้งค่า $m(x) = 0$โดยเข้ารหัสสมมติฐานว่าเราไม่มีอคติต่อผลตอบแทนมาก่อน โครงสร้างทั้งหมดจะเข้าสู่เคอร์เนล

เหตุใดจึงไม่มีพารามิเตอร์

โมเดลการถดถอยเชิงเส้นที่มี 5 คุณลักษณะมี 6 พารามิเตอร์ โครงข่ายประสาทเทียมที่มีสองชั้นซ่อนอยู่ 64 ยูนิตมีหลายพันยูนิต GP ไม่มีจำนวนพารามิเตอร์คงที่ — ความซับซ้อนของแบบจำลองจะเพิ่มขึ้นตามข้อมูล ด้วยการสังเกต 10 ครั้ง GP ให้นิยามเกาส์เซียน 10 มิติ ด้วยการสังเกต 10,000 ครั้ง จะกำหนดเกาส์เซียน 10,000 มิติ

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

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

ฟังก์ชั่นเคอร์เนล: การเข้ารหัสโครงสร้างตลาด

ฟังก์ชันเคอร์เนล $k(x, x')$ คือจิตวิญญาณของกระบวนการแบบเกาส์เซียน โดยจะกำหนดฟังก์ชันที่น่าจะเป็นนิรนัยโดยระบุความแปรปรวนร่วมระหว่างค่าฟังก์ชันที่จุดอินพุตสองจุดใดๆ เมล็ดพืชที่ต่างกันจะเข้ารหัสสมมติฐานที่แตกต่างกันเกี่ยวกับความเรียบ ช่วงเวลา และพฤติกรรมในระยะยาว

ฟังก์ชัน Radial Basis (RBF) / เอ็กซ์โปเนนเชียลกำลังสอง

เคอร์เนล RBF เป็นจุดเริ่มต้นที่พบบ่อยที่สุด:

$k_{\text{RBF}}(x, x') = \sigma^2 \exp\left(-\frac{\|x - x'\|^2}{2\ell^2}\right)$

ที่ไหน $\sigma^2$ คือความแปรปรวนของสัญญาณ (สเกลเอาต์พุต) และ $\ell$ คือสเกลความยาว ฟังก์ชันที่ดึงมาจาก GP ด้วยเคอร์เนล RBF นั้นสร้างความแตกต่างได้อย่างไม่มีที่สิ้นสุด — ราบรื่นมาก

การตีความการซื้อขาย: สเกลความยาว $\ell$ ควบคุมว่าจุดข้อมูลสองจุดจะอยู่ห่างกันเพียงใดและยังคงมีความสัมพันธ์กัน สเกลความยาวสั้นหมายความว่าโมเดลตอบสนองต่อรูปแบบท้องถิ่น สเกลความยาวที่ยาวหมายความว่าสามารถจับแนวโน้มในวงกว้างได้ ความแปรปรวนของสัญญาณ $\sigma^2$ ควบคุมความกว้างของฟังก์ชัน — ผลตอบแทนที่คาดการณ์ไว้จะมีได้มากเพียงใด

ปัญหาด้านการเงิน: ความราบรื่นไร้ขีดจำกัดนั้นไม่สมจริง ผลตอบแทนทางการเงินมีการกระโดด การเปลี่ยนแปลงระบอบการปกครอง และความไม่ต่อเนื่อง เคอร์เนล RBF สามารถปรับคุณสมบัติเหล่านี้ให้เรียบได้ ทำให้เกิดการคาดการณ์ที่ระมัดระวังเกินไปเมื่อใกล้จะเกิดการแตกหักของโครงสร้าง

เคอร์เนลคุณแม่

คลาส Matern จะทำให้ RBF เป็นภาพรวมโดยการแนะนำพารามิเตอร์ความเรียบ $\nu$:

$k_{\text{Matern}}(x, x') = \sigma^2 \frac{2^{1-\nu}}{\Gamma(\nu)} \left(\frac{\sqrt{2\nu}\|x - x'\|}{\ell}\right)^{\nu} K_{\nu}\left(\frac{\sqrt{2\nu}\|x - x'\|}{\ell}\right)$

ที่ไหน $K_{\nu}$ เป็นฟังก์ชัน Bessel ที่ถูกดัดแปลงของชนิดที่สอง เช่น $\nu \to \infty$เคอร์เนล Matern มาบรรจบกับ RBF ตัวเลือกทั่วไป:

• $\nu = 1/2$: เทียบเท่ากับกระบวนการออร์นสไตน์-อูเลนเบค ฟังก์ชันมีความต่อเนื่องแต่ไม่สามารถแยกความแตกต่างได้ — หยาบ เช่น การเคลื่อนที่แบบบราวเนียน
• $\nu = 3/2$: ฟังก์ชันต่างๆ ครั้งหนึ่งสามารถสร้างความแตกต่างได้ ความสมดุลที่ดีระหว่างความนุ่มนวลและความยืดหยุ่น
• $\nu = 5/2$: ฟังก์ชันสามารถหาอนุพันธ์ได้สองเท่า เนียนกว่า. $3/2$ แต่แข็งน้อยกว่า RBF

การตีความการซื้อขาย: มารดา-$3/2$ เคอร์เนลถือเป็นค่าเริ่มต้นที่ดีที่สุดสำหรับอนุกรมเวลาทางการเงิน ช่วยให้เกิดความหยาบแบบที่เส้นทางราคาจริงแสดงโดยไม่ขรุขระเหมือน $\nu = 1/2$. สิ่งนี้สอดคล้องกับวรรณกรรม "ความผันผวนนั้นคร่าวๆ" (Gatheral, Jaisson, & Rosenbaum, 2018) ซึ่งแสดงให้เห็นเชิงประจักษ์ว่าเส้นทางความผันผวนมีเลขชี้กำลัง Hurst อยู่รอบๆ $H \approx 0.1$หยาบกว่าการเคลื่อนไหวแบบบราวเนียนมาก

หลักฐานหลักที่ตีพิมพ์สำหรับเมล็ดแม่ที่เอาชนะแบบจำลองความผันผวนแบบคลาสสิกคือ Rizvi และคณะ (2017) ซึ่งรายงานว่า MSE ดีกว่าการเดินแบบสุ่มประมาณ 20% และดีกว่า GARCH ประมาณ 50% — จากข้อมูลคู่สกุลเงินรายวันในปี 2017 ไม่ใช่การเข้ารหัสลับ และไม่ได้ทำซ้ำที่นี่ ถือว่ามันเป็นแรงจูงใจในการลองใช้เคอร์เนล ไม่ใช่เป็นเกณฑ์มาตรฐาน GARCH(1,1) ของบล็อกนี้เหมาะสมกับข้อมูล BTC จริงรายวัน พร้อมด้วยการวินิจฉัย Ljung-Box และ ARCH-LM อยู่ใน การคาดการณ์ความผันผวนของ GARCH สำหรับสกุลเงินดิจิทัล; การเผชิญหน้ากันแบบตัวต่อตัวกับ Matern GP ในกลุ่มตัวอย่างเดียวกันจะเป็นการเปรียบเทียบที่ตรงไปตรงมา และยังไม่ได้ดำเนินการ

เคอร์เนลเป็นระยะ

ตลาดการเงินมีรูปแบบวัฏจักร: เส้นปริมาณระหว่างวัน ผลกระทบแบบวันในสัปดาห์ กระแสการปรับสมดุลรายเดือน ฤดูกาลรายได้รายไตรมาส เคอร์เนลเป็นระยะจะจับสิ่งเหล่านี้:

$k_{\text{Periodic}}(x, x') = \sigma^2 \exp\left(-\frac{2\sin^2\left(\pi|x - x'|/p\right)}{\ell^2}\right)$

ที่ไหน $p$ คือช่วงเวลา ฟังก์ชันที่ดึงมาจากเคอร์เนลนี้จะทำซ้ำตามจุด $p$, ปรับตามมาตราส่วนความยาว $\ell$ ซึ่งควบคุมว่าความสัมพันธ์จะสลายไปเร็วแค่ไหนภายในระยะเวลาหนึ่ง

การตีความการซื้อขาย: ชุด $p = 24$ (ชั่วโมง) เพื่อจับรูปแบบระหว่างวัน หรือ $p = 5$ (วันซื้อขาย) สำหรับฤดูกาลรายสัปดาห์ เคอร์เนลคาบไม่เหมือนกับคุณสมบัติฟูริเยร์ที่ไม่ถือว่ามีจำนวนฮาร์โมนิกคงที่ GP จะเรียนรู้รูปร่างของวงจรจากข้อมูล

การรวมเมล็ด: องค์ประกอบเพิ่มเติมและการคูณ

พลังที่แท้จริงของเมล็ด GP อยู่ที่องค์ประกอบ ถ้า $k_1$ และ $k_2$ เป็นเมล็ดที่ถูกต้อง ดังนั้น:

• ผลรวม: $k_1 + k_2$ — ฟังก์ชันคือผลรวมของส่วนประกอบอิสระ (การสลายตัวแบบเติม)
• สินค้า: $k_1 \times k_2$ — ปฏิสัมพันธ์ระหว่างองค์ประกอบ (เช่น พฤติกรรมเป็นระยะในท้องถิ่น)

เคอร์เนลคอมโพสิตที่มีประโยชน์สำหรับผลตอบแทนทางการเงิน:

$k(x, x') = k_{\text{Matern-3/2}}(x, x') + k_{\text{Periodic}}(x, x') \cdot k_{\text{RBF}}(x, x')$

สิ่งนี้จะสลายสัญญาณเป็น:

1. องค์ประกอบแนวโน้มที่ไม่ราบรื่นและเป็นระยะ (Matern-3/2)
2. องค์ประกอบคาบซึ่งแอมพลิจูดสลายตัวไปตามกาลเวลา (Periodic $\times$ RBF)

สินค้า $k_{\text{Periodic}} \cdot k_{\text{RBF}}$ สร้างเคอร์เนล ตามระยะเวลาเฉพาะที่: รูปแบบจะเกิดขึ้นซ้ำ แต่การซ้ำซ้อนในระยะไกลมีอิทธิพลน้อยกว่าสิ่งใกล้เคียง สิ่งนี้เหมาะสมอย่างยิ่งกับฤดูกาลทางการเงิน ซึ่งเปลี่ยนแปลงไปตามเวลาเนื่องจากโครงสร้างจุลภาคของตลาดมีการพัฒนา

เมล็ดผสมสเปกตรัม

เพื่อความยืดหยุ่นสูงสุด เคอร์เนลผสมสเปกตรัม (SM) (Wilson & Adams, 2013) จะกำหนดพารามิเตอร์ความหนาแน่นสเปกตรัมของเคอร์เนลเป็นส่วนผสมของ Gaussians:

$k_{\text{SM}}(x, x') = \sum_{q=1}^{Q} w_q \exp\left(-2\pi^2 \|x - x'\|^2 v_q\right) \cos\left(2\pi \|x - x'\| \mu_q\right)$

ที่ไหน $w_q$ คือน้ำหนักผสม $v_q$ คือความแปรปรวนทางสเปกตรัม และ $\mu_q$ เป็นค่าเฉลี่ยสเปกตรัม (ความถี่) ตามทฤษฎีบทของบอชเนอร์ เคอร์เนลที่อยู่นิ่งใดๆ สามารถแสดงได้ด้วยวิธีนี้ เคอร์เนล SM สามารถค้นพบส่วนประกอบที่เป็นคาบ แนวโน้มระยะยาว และความสัมพันธ์ระยะสั้นได้พร้อมๆ กัน ทั้งหมดนี้มาจากข้อมูล

การตีความการซื้อขาย: เคอร์เนล SM มีประโยชน์เมื่อคุณไม่ทราบว่ามีรูปแบบใดอยู่ในข้อมูล สามารถระบุช่วงเวลาที่ซ่อนอยู่ในชุดผลตอบแทน (เช่น รอบ 4 ชั่วโมงเล็กๆ น้อยๆ ในตลาด crypto ที่ขับเคลื่อนโดยการปรับสมดุลอัตโนมัติ) ข้อเสียคือมีไฮเปอร์พารามิเตอร์มากขึ้นและมีความเสี่ยงที่จะติดตั้งชุดข้อมูลขนาดเล็กมากเกินไป

การอนุมานภายหลัง: จากก่อนถึงการคาดการณ์

ได้รับข้อมูลการฝึกอบรม $\mathcal{D} = \{(x_i, y_i)\}_{i=1}^n$ ที่ไหน $y_i = f(x_i) + \epsilon_i$ และ $\epsilon_i \sim \mathcal{N}(0, \sigma_n^2)$, GP ด้านหลังที่จุดทดสอบ $X_*$ มีวิธีแก้ปัญหาแบบปิด นี่เป็นข้อได้เปรียบทางการคำนวณที่สำคัญของ GP เหนือโมเดล Bayesian ส่วนใหญ่

สมการหลัง

ปล่อย $K = k(X, X)$ เป็น $n \times n$ การฝึกอบรมเมทริกซ์ความแปรปรวนร่วม $K_* = k(X_*, X)$ เป็น $m \times n$ เมทริกซ์ความแปรปรวนร่วมข้าม และ $K_{**} = k(X_*, X_*)$ เป็น $m \times m$ ทดสอบเมทริกซ์ความแปรปรวนร่วม ด้านหลังคือ:

$f_* | X, y, X_* \sim \mathcal{N}(\bar{f}_*, \text{Cov}(f_*))$

ที่ไหน:

$\bar{f}_* = K_* (K + \sigma_n^2 I)^{-1} y$

$\text{Cov}(f_*) = K_{**} - K_* (K + \sigma_n^2 I)^{-1} K_*^T$

ค่าเฉลี่ยหลัง $\bar{f}_*$ เป็นการผสมผสานเชิงเส้นของเป้าหมายการฝึกอบรม โดยถ่วงน้ำหนักด้วยความคล้ายคลึงกันของเคอร์เนลระหว่างจุดทดสอบและจุดฝึกอบรม ความแปรปรวนร่วมหลัง $\text{Cov}(f_*)$ เริ่มต้นจากความแปรปรวนร่วมก่อนหน้า $K_{**}$ และลบข้อมูลที่ได้รับจากข้อมูลการฝึกอบรม ในกรณีที่ข้อมูลการฝึกอบรมมีความหนาแน่น ความแปรปรวนหลังจะมีน้อย ในกรณีที่ข้อมูลการฝึกอบรมกระจัดกระจาย ความแปรปรวนหลังจะเปลี่ยนกลับเป็นข้อมูลก่อนหน้า

ความเป็นไปได้เล็กน้อยและการทดสอบมูลค่าการเรียกร้อง

ไฮเปอร์พารามิเตอร์เคอร์เนล $\theta$ (สเกลความยาว ความแปรปรวน ระดับเสียง) ได้รับการเรียนรู้โดยการเพิ่มโอกาสส่วนเพิ่มของบันทึกให้สูงสุด:

$\log p(y | X, \theta) = -\frac{1}{2} y^T (K + \sigma_n^2 I)^{-1} y - \frac{1}{2} \log |K + \sigma_n^2 I| - \frac{n}{2} \log 2\pi$

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

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

การกล่าวอ้างดังกล่าวสมควรได้รับความสงสัยในบล็อกนี้โดยเฉพาะ การวิเคราะห์ที่ราบสูง แสดงให้เห็นว่าคะแนนการตรวจสอบความถูกต้องจุดเดียวถือเป็นเกณฑ์การคัดเลือกที่ไม่ดี และความเข้มแข็งนั้นดำรงอยู่ในรูปของพื้นที่ใกล้เคียง PBO เป็นตัวระบุความถี่ที่ผู้ชนะในกลุ่มตัวอย่างสูญเสียออกจากกลุ่มตัวอย่าง กิ่ว Sharpe ราคาในจำนวนการทดลอง ความน่าจะเป็นส่วนเพิ่มยังคงเป็นวัตถุประสงค์ในตัวตัวอย่างที่ถูกขยายให้ใหญ่สุด $\theta$ — ปัจจัย Occam จะลงโทษโมเดล ความจุ ไม่ใช่ การเลือกเคอร์เนลที่ติดตั้งไว้จำนวนมาก หากคุณใส่เมล็ดพืชที่เข้าข่ายได้สิบสองเมล็ด และเลือกอันที่มีความน่าจะเป็นส่วนเพิ่มที่ดีที่สุด คุณจะกลับมาอยู่ในขอบเขตการทดสอบหลายรายการ และตรรกะภาวะเงินฝืดจะไม่เปลี่ยนแปลง เวอร์ชันที่ปลอมแปลงได้: การเลือกความน่าจะเป็นส่วนเพิ่มทำให้เกิดช่องว่างในตัวอย่าง/ไม่อยู่ในตัวอย่างน้อยกว่าการเลือกชุดการตรวจสอบความถูกต้องในข้อมูลเดียวกันและตระกูลเคอร์เนลเดียวกันหรือไม่ ที่สามารถวัดได้และไม่ได้วัดด้านล่าง

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

ต้นทุนการคำนวณและความสามารถในการขยายขนาด

คอขวดกำลังกลับด้าน $(K + \sigma_n^2 I)$ซึ่งมีค่าใช้จ่าย $O(n^3)$ ทันเวลาและ $O(n^2)$ ในความทรงจำ กำแพงลูกบาศก์เป็นที่ถกเถียงกันอยู่แล้วในบล็อกนี้จากอีกทางหนึ่ง: วิธีการค้นหาเทียบกับต้นทุนการประเมิน จะตัดสิทธิ์การเพิ่มประสิทธิภาพแบบเบย์เซียนที่ใช้ GP ทันทีเมื่อวัตถุประสงค์มีราคาถูก เนื่องจากตัวแทนมีค่าใช้จ่ายมากกว่าการประเมินที่บันทึกไว้ เลขคณิตก็เหมือนกันที่นี่ แอปพลิเคชันแตกต่างกัน เนื่องจากเป็น โมเดล ที่เหมาะกับข้อมูลตลาด คำศัพท์แบบลูกบาศก์จึงไม่ใช่การตัดสิทธิ์ แต่เป็นงบประมาณ: เป็นการกำหนดเพดานที่เข้มงวดในหน้าต่างการฝึกอบรม

กลยุทธ์การขยายขนาดสำหรับแอปพลิเคชันการซื้อขาย:

1. Sparse GP (จุดกระตุ้น) เปลี่ยน $n \times n$ เมทริกซ์ด้วย $m \times m$ เมทริกซ์อยู่ที่ไหน $m \ll n$. จุดกระตุ้น $Z = \{z_1, \ldots, z_m\}$ เป็นอินพุตหลอกที่สรุปข้อมูลการฝึกอบรม สูตร SVGP (Stochastic Variational GP) โดย Hensman และคณะ (2013) อนุญาตให้มีการฝึกอบรมแบบชุดย่อยโดยมีค่าใช้จ่าย $O(nm^2)$ ต่อการวนซ้ำ GPyTorch รองรับสิ่งนี้โดยกำเนิด

2. การแก้ไขเคอร์เนลที่มีโครงสร้าง (SKI/KISS-GP) ใช้ประโยชน์จากโครงสร้าง Kronecker และ Toeplitz ในเมทริกซ์เคอร์เนลเมื่ออินพุตอยู่บนตาราง ลดต้นทุนให้กับ $O(n + g \log g)$ ที่ไหน $g$ คือขนาดกริด เหมาะสำหรับอนุกรมเวลาสุ่มตัวอย่างเป็นประจำ (เช่น แท่ง 1 นาที)

3. GP ท้องถิ่นบนหน้าต่างบานเลื่อน ฝึก GP แยกจากข้อมูลล่าสุดเท่านั้น นี่คือจุดที่ข้อจำกัดเฉพาะของ GP กัด: เคอร์เนลมาตรฐานอยู่นิ่ง ($k(x,x')$ ขึ้นอยู่กับเท่านั้น $x - x'$) และตลาดไม่ใช่ ดังนั้นคำตอบปกติคือหน้าต่างแบบม้วน — แต่ความยาวของหน้าต่างถูกจำกัดไว้ด้านบน $O(n^3)$ไม่ใช่แค่ตามสถิติเท่านั้น การเพิ่มประสิทธิภาพ Walk-forward ครอบคลุมหน้าต่างแบบยึดกับแบบเลื่อน ความยาวการฝึก/การทดสอบ และความถี่ในการปรับให้เหมาะสมโดยทั่วไปอีกครั้ง สำหรับ GP การกำหนดขนาดหน้าต่างเป็นการตัดสินใจในการคำนวณมากเท่ากับการวัดทางสถิติ และหน้าต่างที่ยึด (เพิ่มขึ้นเรื่อย ๆ ) นั้นไม่สามารถใช้งานได้เกินสองสามพันจุดโดยไม่มีการประมาณ การปรับเฟรมใหม่นั้นเป็นผลที่ตามมาในทางปฏิบัติ: ด้วย GP คุณจะไม่ต้องเลือก "ใช้ประวัติทั้งหมด"

GP สำหรับการทำนายผลตอบแทน: กรอบการทำงานที่ใช้งานได้จริง

การออกแบบคุณลักษณะ: ทำไมต้องมี 5-20 คุณลักษณะ ไม่ใช่ 500

อนุกรมวิธานคุณลักษณะทั่วไปสำหรับ ML ของข้อมูลตลาด — ความไม่สมดุลของสมุดคำสั่งซื้อ, แรงกดดันจากหนังสือ, VPIN, lambda ของ Kyle, คุณสมบัติความผันผวนที่เกิดขึ้นจริง, การเข้ารหัสเวลาแบบวัฏจักร, สัญญาณข้ามสินทรัพย์ และอัตราการระดมทุน — ได้วางไว้แล้วใน การสร้างแบบจำลองสเปรดด้วยการเรียนรู้ของเครื่อง; ใช้รายการนั้น

เฉพาะ GP คืออะไร ขนาด ของรายการ วิธีการเคอร์เนลจะลดลงในมิติสูง: ระยะทางรวมศูนย์ และเคอร์เนลที่อยู่นิ่งจะสูญเสียการเลือกปฏิบัติ ระยะการใช้งานจริงสำหรับ GP ทางการเงินคือ 5-20 อินพุต ไม่ใช่หลายร้อยที่ต้นไม้ที่เพิ่มการไล่ระดับสีกินอย่างมีความสุข กลไกที่ทำให้สิ่งนี้อยู่รอดได้คือ ARD (Automatic Relevance Termation): ให้แต่ละมิติอินพุตมีระดับความยาวของตัวเอง $\ell_d$และการฝึกอบรมความน่าจะเป็นแบบชายขอบ $\ell_d \to \infty$ สำหรับมิติที่ไม่มีสัญญาณ เนื่องจากมาตราส่วนความยาวไม่สิ้นสุดหมายความว่าเคอร์เนลจะละเว้นพิกัดนั้น การเลือกคุณสมบัติกลายเป็นผลพลอยได้จากความเหมาะสมและการเรียนรู้ $\ell_d$ สามารถอ่านได้โดยตรงเป็นการจัดอันดับความเกี่ยวข้อง ซึ่งเป็นสิ่งที่ทำให้สามารถปลอมแปลงได้ เช่น ติดตั้งเคอร์เนลคอมโพสิตบนแท่งจริง พิมพ์สเกลความยาว และดูว่าคุณสมบัติที่คุณเชื่อนั้นเป็นคุณสมบัติที่โมเดลเก็บไว้หรือไม่

การกำหนดขนาดตำแหน่งและการงดออกเสียง

GP หลังให้ $\sigma_*(x)$ โดยตรง ดังนั้นมันจึงตกลงตรงไปยังขนาดอัตราส่วนขอบและตัวกรองการไม่เทรดที่พัฒนาขึ้นใน การทำนายตามรูปแบบสำหรับขนาดตำแหน่งที่รับรู้ความเสี่ยง พร้อมความกว้างของช่วงเวลา $w_t = 2\kappa\sigma_*(x)$. ข้อแตกต่างเพียงอย่างเดียวคือที่มา: GP จะสร้างความกว้างจากแบบจำลองแทนที่จะสร้างจากชุดการสอบเทียบ ดังนั้นจึงแตกต่างกันไปตามตำแหน่งของจุดทดสอบที่สัมพันธ์กับข้อมูลการฝึก แทนที่จะสร้างด้วยปริมาณทั่วโลกของสารตกค้างในอดีต

การใช้งานกับ GPyTorch

GPyTorch เป็นไลบรารีที่ใช้ PyTorch สำหรับการอนุมาน GP ที่ปรับขนาดได้ มันใช้ประโยชน์จากการเร่งความเร็วของ GPU การสร้างความแตกต่างอัตโนมัติ และเทคนิคพีชคณิตเชิงเส้นสมัยใหม่ (การไล่ระดับสีแบบคอนจูเกต การสลายตัวของ Lanczos) เพื่อปรับขนาด GP ให้เกินกว่าความไร้เดียงสา $O(n^3)$ ขีด จำกัด

GP ที่แน่นอนขั้นพื้นฐานสำหรับการทำนายผลตอบแทน

import torch
import gpytorch
import numpy as np
from torch.utils.data import TensorDataset, DataLoader


class ExactGPModel(gpytorch.models.ExactGP):
    """Exact GP with a composite kernel for financial returns."""

    def __init__(self, train_x, train_y, likelihood):
        super().__init__(train_x, train_y, likelihood)
        self.mean_module = gpytorch.means.ZeroMean()

        self.covar_matern = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.MaternKernel(nu=1.5, ard_num_dims=train_x.shape[1])
        )
        self.covar_periodic = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.PeriodicKernel()
        )
        self.covar_rbf_decay = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.RBFKernel()
        )

    def forward(self, x):
        mean = self.mean_module(x)
        covar = self.covar_matern(x) + self.covar_periodic(x) * self.covar_rbf_decay(x)
        return gpytorch.distributions.MultivariateNormal(mean, covar)

ard_num_dims คือสิ่งที่ทำให้สามารถกำหนดมาตราส่วนความยาวต่อมิติที่กล่าวถึงข้างต้นได้ หลังจากการฝึกอบรม model.covar_matern.base_kernel.lengthscale เป็นเวกเตอร์ที่อ่านออกมา

ห่วงการฝึกอบรม

def train_gp(train_x, train_y, n_epochs=200, lr=0.05, device=None):
    """Train the GP by maximizing the marginal log-likelihood.

    Returns the device alongside the model so that callers move test
    tensors to the same place -- otherwise prediction crashes on GPU.
    """
    if device is None:
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    train_x = train_x.to(device)
    train_y = train_y.to(device)

    likelihood = gpytorch.likelihoods.GaussianLikelihood().to(device)
    model = ExactGPModel(train_x, train_y, likelihood).to(device)

    model.train()
    likelihood.train()

    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)

    losses = []
    for epoch in range(n_epochs):
        optimizer.zero_grad()
        output = model(train_x)
        loss = -mll(output, train_y)
        loss.backward()
        optimizer.step()
        losses.append(loss.item())

        if (epoch + 1) % 50 == 0:
            noise = likelihood.noise.item()
            print(
                f"Epoch {epoch+1}/{n_epochs} | "
                f"Loss: {loss.item():.4f} | "
                f"Noise: {noise:.6f}"
            )

    return model, likelihood, device, losses

การทำนายด้วยความไม่แน่นอน

def predict_with_uncertainty(model, likelihood, test_x, device):
    """Generate predictions with uncertainty estimates."""
    model.eval()
    likelihood.eval()

    test_x = test_x.to(device)

    with torch.no_grad(), gpytorch.settings.fast_pred_var():
        posterior = likelihood(model(test_x))

        mean = posterior.mean
        variance = posterior.variance
        lower, upper = posterior.confidence_region()  # 2-sigma bounds

    return {
        "mean": mean.cpu().numpy(),
        "std": variance.sqrt().cpu().numpy(),
        "lower_2sigma": lower.cpu().numpy(),
        "upper_2sigma": upper.cpu().numpy(),
    }

ที่ fast_pred_var() ตัวจัดการบริบทใช้อัลกอริธึม LOVE (Lanczos Variance Estimates) เพื่อคำนวณความแปรปรวนในการทำนาย $O(n)$ เวลาแทน $O(n^2)$.

ขั้นตอนการซื้อขายแบบ end-to-end

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

import pandas as pd


def build_features(df: pd.DataFrame, lookback: int = 10) -> pd.DataFrame:
    """Build features for GP-based return prediction."""
    features = pd.DataFrame(index=df.index)

    for lag in range(1, lookback + 1):
        features[f"ret_lag_{lag}"] = df["close"].pct_change().shift(lag)

    ret = df["close"].pct_change()
    features["vol_ratio"] = (
        ret.rolling(10).std() / ret.rolling(50).std()
    )

    features["vol_zscore"] = (
        (df["volume"] - df["volume"].rolling(50).mean())
        / df["volume"].rolling(50).std()
    )

    if "bid_vol" in df.columns and "ask_vol" in df.columns:
        features["obi"] = (
            (df["bid_vol"] - df["ask_vol"])
            / (df["bid_vol"] + df["ask_vol"])
        )

    if hasattr(df.index, "hour"):
        hours = df.index.hour + df.index.minute / 60.0
        features["time_sin"] = np.sin(2 * np.pi * hours / 24)
        features["time_cos"] = np.cos(2 * np.pi * hours / 24)

    features.dropna(inplace=True)
    return features


def run_gp_strategy(
    df: pd.DataFrame,
    train_window: int = 500,
    retrain_every: int = 50,
    confidence_threshold: float = 1.0,
    risk_fraction: float = 0.02,
    max_leverage: float = 1.0,
):
    """Walk-forward GP trading strategy with uncertainty-based sizing."""
    features = build_features(df)
    returns = df["close"].pct_change().reindex(features.index)
    target = returns.shift(-1)  # predict next-bar return

    mask = features.notna().all(axis=1) & target.notna()
    features = features[mask]
    target = target[mask]

    positions = pd.Series(0.0, index=features.index)
    predictions = pd.DataFrame(
        index=features.index, columns=["mean", "std"], dtype=float
    )

    model = likelihood = device = None
    x_mean = x_std = y_mean = y_std = None

    for i in range(train_window, len(features)):
        if model is None or (i - train_window) % retrain_every == 0:
            train_x = torch.tensor(
                features.iloc[i - train_window : i].values,
                dtype=torch.float32,
            )
            train_y = torch.tensor(
                target.iloc[i - train_window : i].values,
                dtype=torch.float32,
            )

            x_mean, x_std = train_x.mean(0), train_x.std(0) + 1e-8
            y_mean, y_std = train_y.mean(), train_y.std() + 1e-8
            train_x_norm = (train_x - x_mean) / x_std
            train_y_norm = (train_y - y_mean) / y_std

            model, likelihood, device, _ = train_gp(
                train_x_norm, train_y_norm, n_epochs=100
            )

        test_x = torch.tensor(
            features.iloc[i : i + 1].values, dtype=torch.float32
        )
        test_x_norm = (test_x - x_mean) / x_std

        pred = predict_with_uncertainty(model, likelihood, test_x_norm, device)

        pred_mean = pred["mean"][0] * y_std.item() + y_mean.item()
        pred_std = pred["std"][0] * y_std.item()

        predictions.iloc[i] = [pred_mean, pred_std]

        z_score = abs(pred_mean) / (pred_std + 1e-8)
        if z_score > confidence_threshold:
            size = min(z_score * risk_fraction, max_leverage)
            positions.iloc[i] = np.sign(pred_mean) * size

    strategy_returns = positions.shift(1) * returns
    return strategy_returns, predictions, positions

ปรับขนาดเป็นชุดข้อมูลขนาดใหญ่ขึ้นด้วย Sparse GP

เมื่อกรอบเวลาการฝึกอบรมเกินสองสามพันจุด การอนุมาน GP ที่แน่นอนจะช้าลง เปลี่ยนไปใช้ GP แบบกระจัดกระจายแบบแปรผัน:

class SparseGPModel(gpytorch.models.ApproximateGP):
    """Sparse variational GP for large-scale return prediction."""

    def __init__(self, inducing_points):
        variational_distribution = (
            gpytorch.variational.CholeskyVariationalDistribution(
                inducing_points.size(0)
            )
        )
        variational_strategy = (
            gpytorch.variational.VariationalStrategy(
                self,
                inducing_points,
                variational_distribution,
                learn_inducing_locations=True,
            )
        )
        super().__init__(variational_strategy)
        self.mean_module = gpytorch.means.ZeroMean()
        self.covar_module = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.MaternKernel(nu=1.5)
        )

    def forward(self, x):
        mean = self.mean_module(x)
        covar = self.covar_module(x)
        return gpytorch.distributions.MultivariateNormal(mean, covar)


def train_sparse_gp(train_x, train_y, n_inducing=128, n_epochs=50, batch_size=256):
    """Train sparse GP with mini-batch stochastic variational inference."""
    indices = torch.randperm(train_x.size(0))[:n_inducing]
    inducing_points = train_x[indices]

    model = SparseGPModel(inducing_points)
    likelihood = gpytorch.likelihoods.GaussianLikelihood()

    model.train()
    likelihood.train()

    optimizer = torch.optim.Adam(
        [{"params": model.parameters()}, {"params": likelihood.parameters()}],
        lr=0.01,
    )
    mll = gpytorch.mlls.VariationalELBO(
        likelihood, model, num_data=train_y.size(0)
    )

    dataset = TensorDataset(train_x, train_y)
    loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    for epoch in range(n_epochs):
        for x_batch, y_batch in loader:
            optimizer.zero_grad()
            output = model(x_batch)
            loss = -mll(output, y_batch)
            loss.backward()
            optimizer.step()

    return model, likelihood

ด้วยคะแนนกระตุ้น 128 คะแนน ต้นทุนต่อชุดคือ $O(128^2 \times \text{batch\_size})$ — ประมาณ 4 ล้านการดำเนินงานต่อชุด สิ่งนี้จัดการชุดข้อมูลของการสังเกตมากกว่า 100,000 รายการบน GPU ตัวเดียวได้อย่างง่ายดาย

การเรียนรู้เคอร์เนลเชิงลึก: GP พบกับโครงข่ายประสาทเทียม

เมื่อพื้นที่อินพุตเป็นมิติสูงหรือความสัมพันธ์ระหว่างคุณลักษณะและการส่งคืนมีความไม่เชิงเส้นสูง เคอร์เนลธรรมดาอาจประสบปัญหา การเรียนรู้เคอร์เนลเชิงลึก (DKL) จะส่งผ่านอินพุตผ่านโครงข่ายประสาทเทียมก่อนที่จะใช้เคอร์เนล GP:

$k_{\text{DKL}}(x, x') = k_{\text{base}}(g_\phi(x), g_\phi(x'))$

ที่ไหน $g_\phi$ เป็นโครงข่ายประสาทเทียมที่มีพารามิเตอร์ $\phi$ และ $k_{\text{base}}$ เป็นเคอร์เนลมาตรฐาน (เช่น Matern-3/2) เครือข่ายเรียนรู้การแสดงคุณลักษณะที่เคอร์เนล GP มีประสิทธิภาพสูงสุด โมเดลทั้งหมด — พารามิเตอร์เครือข่ายและไฮเปอร์พารามิเตอร์เคอร์เนล — ได้รับการฝึกฝนตั้งแต่ต้นทางถึงปลายทางโดยการเพิ่มโอกาสส่วนเพิ่มให้สูงสุด

class DeepKernelGP(gpytorch.models.ExactGP):
    """GP with a neural network feature extractor."""

    def __init__(self, train_x, train_y, likelihood, input_dim):
        super().__init__(train_x, train_y, likelihood)
        self.mean_module = gpytorch.means.ZeroMean()

        self.feature_extractor = torch.nn.Sequential(
            torch.nn.Linear(input_dim, 8),
            torch.nn.ReLU(),
            torch.nn.Linear(8, 4),
            torch.nn.ReLU(),
            torch.nn.Linear(4, 2),
        )

        self.covar_module = gpytorch.kernels.ScaleKernel(
            gpytorch.kernels.MaternKernel(nu=1.5, ard_num_dims=2)
        )

    def forward(self, x):
        features = self.feature_extractor(x)
        mean = self.mean_module(features)
        covar = self.covar_module(features)
        return gpytorch.distributions.MultivariateNormal(mean, covar)

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

Ludkovski and Risk (2025), Gaussian Process Models for Quantitative Finance สำรวจ DKL ในบริบททางการเงินเชิงปริมาณที่กว้างขึ้น รวมถึงการกำหนดราคาออปชั่นและการเพิ่มประสิทธิภาพพอร์ตโฟลิโอ ผลลัพธ์เหล่านั้นขึ้นอยู่กับปัญหาของพวกเขา และไม่ใช่หลักฐานเกี่ยวกับการคาดการณ์ผลตอบแทนของสกุลเงินดิจิทัล

การวินิจฉัยและข้อผิดพลาด

การสอบเทียบ

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

from scipy.stats import norm

def calibration_report(predictions, actuals):
    """Check if GP uncertainty is well-calibrated."""
    z_scores = (actuals - predictions["mean"]) / (predictions["std"] + 1e-8)

    for sigma in [1, 2, 3]:
        expected_outside = 2 * (1 - norm.cdf(sigma))
        actual_outside = (np.abs(z_scores) > sigma).mean()
        print(
            f"{sigma}-sigma | Expected outside: {expected_outside:.3f} | "
            f"Actual outside: {actual_outside:.3f}"
        )

ค่าเกินที่คาดหวังคือ 0.317 / 0.046 / 0.003 ที่ 1/2/3 ซิกมา ตัวเลขที่สำคัญคือสิ่งที่พิมพ์ออกมาบนแท่งสกุลเงินดิจิทัลแบบก้าวไปข้างหน้าอย่างแท้จริง และตารางนั้นยังไม่มีในบทความนี้ ความคาดหวังก่อนหน้าคือ GP มีความมั่นใจมากเกินไป - ความน่าจะเป็นแบบเกาส์เซียนในผลตอบแทนแบบหางอ้วนและไม่อยู่กับที่นั้นควรปกปิดไว้ไม่ดีที่ 3 ซิกมา - แต่ "ควร" ไม่ใช่การวัด

ข้อผิดพลาดที่เหลืออยู่

1. สเกลอินพุต สเกลความยาวสัมพันธ์กับสเกลอินพุต ดังนั้นจึงมีฟีเจอร์อยู่ในช่วง $[0, 10000]$ และอีกอันหนึ่งอยู่ในระยะ $[0, 1]$ ไม่สามารถแบ่งปันความหมายได้ $\ell$; ARD คือสิ่งที่ช่วยรักษาช่วงที่ต่างกัน และการกำหนดมาตรฐานคือสิ่งที่ทำให้การเริ่มต้นของ ARD มีสติ

2. การใส่ความน่าจะเป็นส่วนขอบมากเกินไป ด้วยไฮเปอร์พารามิเตอร์เคอร์เนลจำนวนมาก (โดยเฉพาะเมล็ดผสมแบบผสมหรือสเปกตรัม) ความน่าจะเป็นส่วนขอบยังคงสามารถใส่ได้พอดีเกินไป ใช้ Priors: สเกลปกติก่อนความยาวมีศูนย์กลางที่ระยะมัธยฐานตามคู่ ครึ่งหนึ่งของปกติก่อนความแปรปรวน

3. การปรับสภาพเมทริกซ์ความแปรปรวนร่วม $(K + \sigma_n^2 I)$ จะกลายเป็นตัวเลขเอกพจน์เมื่อมีสัญญาณรบกวน $\sigma_n^2$ เล็กเกินไปหรือเมื่อคะแนนการฝึกเกือบซ้ำกัน GPyTorch เพิ่ม $10^{-6}$ กระวนกระวายใจในแนวทแยง; ข้อมูลทางการเงินที่มีเงื่อนไขไม่ดีมักต้องการมากกว่านี้

4. อคติแบบมองไปข้างหน้า ครอบคลุมอยู่ด้านบนและในรายละเอียดที่วัดได้ใน อนุกรมวิธานอคติแบบมองไปข้างหน้า

เมื่อใดควรใช้ GP เทียบกับรุ่นอื่นๆ

* สำหรับคอลัมน์ XGBoost และเครือข่ายประสาทเทียม โปรดดูการเปรียบเทียบที่เผยแพร่มากกว่าการยืนยันใหม่ที่นี่: การสร้างแบบจำลองการแพร่กระจายด้วยการเรียนรู้ของเครื่อง มีตารางการไล่ระดับสีที่ส่งเสริมเทียบกับการเรียนรู้เชิงลึกสำหรับข้อมูลแบบตารางทางการเงิน (เกณฑ์ขนาดข้อมูล ความสามารถในการตีความ การปรับระบอบการปกครอง เวลาแฝง) และ ฟิวชั่นชั่วคราว Transformers มี TFT เทียบกับ LSTM เทียบกับ vanilla Transformer

ใช้ GP เมื่อ:

• คุณมีชุดข้อมูลขนาดเล็กถึงขนาดกลาง (ต่ำกว่า ~10,000 การสังเกตต่อกรอบเวลาการฝึกอบรม)
• คุณต้องการสมมติฐานเชิงโครงสร้างที่ชัดเจนและตรวจสอบได้เกี่ยวกับสัญญาณ (แนวโน้ม + ฤดูกาล + สัญญาณรบกวน)
• ความไม่แน่นอนต้องแปรผันตามระยะห่างจากข้อมูลการฝึก ไม่ใช่แค่ควอนไทล์ที่เหลือทั่วโลก

อย่าใช้ GP เมื่อ:

• คุณต้องอนุมานต่ำกว่ามิลลิวินาทีจากการสังเกตนับล้านครั้ง
• ขนาดอินพุตเกิน ~50
• สัญญาณอาศัยอยู่ในการโต้ตอบคุณลักษณะลำดับสูงที่ซับซ้อนซึ่งเคอร์เนลที่อยู่นิ่งไม่สามารถเป็นตัวแทนได้ (DKL ช่วยด้วยต้นทุนของคุณสมบัติ Occam)

สิ่งที่บทความนี้ยังไม่ได้วัดผล

ทุกอย่างข้างต้นเป็นเครื่องจักรจำลอง ไม่มีข้อพิสูจน์ใดที่แสดงว่า GP ทำเงินจาก crypto และมาตรฐานของบล็อกนี้คือบทความนี้มีตัวเลขของตัวเอง รายการที่เปิดอยู่ ตามลำดับที่ควรรัน:

1. วัดความยาว ARD บนแท่ง BTCUSDT จริงขนาด 1 ม. ติดตั้งเคอร์เนลคอมโพสิต พิมพ์ $\ell_d$ ต่อคุณลักษณะ นี่เป็นการทดสอบการอ้างสิทธิ์ "ARD คือการเลือกฟีเจอร์ในตัว" โดยตรงและสร้างการจัดอันดับความเกี่ยวข้องของฟีเจอร์ที่สามารถปลอมแปลงได้
2. ตารางการสอบเทียบจากการวิ่งแบบวอล์คไปข้างหน้า สิ่งที่คาดหวังเทียบกับผลเกินเชิงประจักษ์ที่ 1/2/3 ซิกมา ระบุไว้อย่างชัดเจน รวมถึงกรณีที่ GP มีความมั่นใจมากเกินไป
3. กลยุทธ์ที่จำกัดความมั่นใจ เดินหน้าต่อไป ในห้าสาขาหลักเดียวกันกับ ผลลบที่ซื่อสัตย์ กิ่วลงสำหรับการนับการทดลองใช้ หากล้มเหลว จะเข้าสู่ซีรีส์นั้นเป็นผลลบอีกรายการหนึ่ง
4. นาฬิกาแขวน $O(n^3)$ โค้ง สำหรับ $n = 250 / 500 / 1000 / 2000 / 5000$ตรงทั้งหมดเทียบกับ SVGP ดังนั้นส่วนที่ปรับขนาดได้จึงอยู่บนแผนภูมิแทนที่จะเป็นการยืนยัน

บทสรุป

กรณีของกระบวนการเกาส์เซียนในการซื้อขายไม่ใช่ "พวกมันให้แถบข้อผิดพลาดแก่คุณ" - การทำนายที่สอดคล้องจะให้แถบข้อผิดพลาดแก่คุณโดยมีข้อสันนิษฐานในการกระจายน้อยลง และการรับประกันความครอบคลุมที่ GP ไม่มี กรณีนี้คือ GP ให้คุณเขียนสมมติฐานเชิงโครงสร้างของคุณลงในเคอร์เนล ปรับให้เข้ากับวัตถุประสงค์ที่กำหนดราคาในความซับซ้อนของตัวเอง จากนั้นจะบอกคุณว่าคุณลักษณะใดของคุณที่จริงใช้ผ่านสเกลความยาว ARD นั่นเป็นรูปแบบที่อ่านง่ายผิดปกติ

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

อ้างอิง

• Rasmussen, C.E., และ Williams, C.K.I. (2006) กระบวนการเกาส์เซียนสำหรับการเรียนรู้ของเครื่อง สำนักพิมพ์เอ็มไอที.
• วิลสัน เอ. และอดัมส์ อาร์. (2013) เคอร์เนลกระบวนการเกาส์เซียนสำหรับการค้นหารูปแบบและการประมาณค่า ICML.
• Hensman, J., Fusi, N., และ Lawrence, N.D. (2013) กระบวนการเกาส์เซียนสำหรับข้อมูลขนาดใหญ่ อุ้ย.
• Gatheral, J., Jaisson, T., & Rosenbaum, M. (2018) ความผันผวนเป็นเรื่องหยาบ การเงินเชิงปริมาณ, 18(6)
• Rizvi, S. A. A. , Roberts, S. J. , Osborne, M. A. , & Nyikosa, F. (2017) แนวทางใหม่ในการพยากรณ์ความผันผวนทางการเงินด้วยซองกระบวนการแบบเกาส์เซียน arXiv:1705.00891.
• Ludkovski, M., & Risk, J. (2025) แบบจำลองกระบวนการเกาส์เซียนสำหรับการเงินเชิงปริมาณ สปริงเกอร์.
• Gardner, J. R., Pleiss, G., Bindel, D., Weinberger, K. Q., & Wilson, A. G. (2018) GPyTorch: การอนุมานกระบวนการแบบเกาส์เซียนของ Blackbox Matrix-Matrix พร้อมการเร่งความเร็วของ GPU ประสาทสัมผัส.