Quy trình Gaussian cho mô hình hóa giá phi tham số

Một phần của loạt bài "Các đường cơ sở ML cổ điển".

Có hai điều làm cho quy trình Gaussian đáng được viết riêng trên blog này và cả hai điều đó đều không phải là "nó mang lại cho bạn sự không chắc chắn".

Đầu tiên là thiết kế hạt nhân. Toàn bộ thành kiến ​​quy nạp của GP tồn tại trong một chức năng $k(x, x')$, và chức năng đó là thứ mà bạn cố ý viết ra: đường đi gồ ghề như thế nào, liệu nó có lặp lại hay không, liệu sự lặp lại có phân rã hay không. Không có gì khác trong bộ công cụ tiêu chuẩn cho phép bạn nêu một giả thuyết cấu trúc về động lực thị trường một cách rõ ràng và sau đó phù hợp với nó. Thứ hai là khả năng cận biên — một mục tiêu huấn luyện có mức phạt phức tạp bắt nguồn từ chính mô hình chứ không phải từ một tập hợp đã có sẵn. Mọi bài viết khác trong phần trang bị quá mức trên blog này (phân tích cao nguyên, PBO, deflat Sharpe) đều tồn tại vì quá trình chuẩn hóa bộ xác thực rất dễ bị hỏng trong quá trình tìm kiếm. Một bác sĩ đa khoa tuyên bố không cần. Tuyên bố đó có thể kiểm chứng được và việc kiểm tra nó thú vị hơn một hướng dẫn khác về cách xác định kích thước không chắc chắn.

Về bản thân sự không chắc chắn: phương sai sau GP là cấu trúc - nó nằm ngoài cùng một suy luận tạo ra giá trị trung bình, thay vì được bao bọc xung quanh một mô hình phù hợp sau đó. Đó là sự tương phản thực sự với dự đoán phù hợp, vốn đã đề cập trên blog này tại sao sự không chắc chắn lại là đầu vào phù hợp để định cỡ vị thế và những việc cần làm với một khoảng thời gian khi bạn có khoảng thời gian đó. Bài viết này không tranh luận lại trường hợp đó; nó đi theo mô hình.

Phần tiếp theo là nhân và bộ máy suy luận, cách triển khai GPyTorch và - được nêu rõ ràng ở cuối - các phép đo mà bài viết này chưa có.

Quy trình Gaussian là gì?

Các GP đã xuất hiện trên blog này với tư cách là đại diện thay thế tối ưu hóa Bayes trong Optuna so với tọa độ gốc, với cùng một ký hiệu và cùng một cảnh báo về chiều thấp. Ở đây, GP chính là mô hình, được trang bị cho dữ liệu thị trường thay vì bề mặt tìm kiếm siêu tham số, do đó việc xử lý sẽ đi sâu hơn.

Quá trình Gaussian là một tập hợp các biến ngẫu nhiên, bất kỳ số lượng hữu hạn nào trong số đó đều có phân phối Gaussian chung. Nó là sự phân phối theo các hàm, không phải là sự phân phối theo các tham số.

Về mặt hình thức, một chức năng $f: \mathcal{X} \to \mathbb{R}$ được rút ra từ GP nếu với bất kỳ tập hợp hữu hạn đầu vào nào $\{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)$

Ở đâu $m(x) = \mathbb{E}[f(x)]$ là hàm trung bình và $k(x, x') = \text{Cov}(f(x), f(x'))$ là hàm hiệp phương sai (hạt nhân). Chúng ta viết gọn lại như sau:

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

Hàm trung bình mã hóa niềm tin trước đây về hành vi trung bình của $f$. Trong giao dịch, chúng ta thường đặt $m(x) = 0$, mã hóa giả định rằng chúng ta không có định hướng trước về lợi nhuận. Tất cả cấu trúc đi vào kernel.

Tại sao không có tham số?

Mô hình hồi quy tuyến tính với 5 đặc trưng có 6 tham số. Một mạng lưới thần kinh có hai lớp ẩn gồm 64 đơn vị có hàng ngàn đơn vị. GP không có số lượng tham số cố định - độ phức tạp của mô hình tăng theo dữ liệu. Với 10 quan sát, GP xác định Gaussian 10 chiều. Với 10.000 quan sát, nó xác định Gaussian 10.000 chiều.

Điều này không có nghĩa là GP không có siêu tham số. Hàm hạt nhân có các siêu tham số (thang độ dài, biên độ, chu kỳ) kiểm soát các thuộc tính của các hàm được rút ra từ trước đó. Nhưng bản thân hình thức chức năng không bao giờ cố định. GP có thể đại diện cho bất kỳ hàm liên tục nào, được cung cấp đủ dữ liệu và hạt nhân phù hợp. Đây chính là ý nghĩa của "phi tham số" - mô hình không bị ràng buộc trong họ tham số như hàm tuyến tính hoặc đa thức.

Đối với mô hình tài chính, điều này rất có giá trị. Thị trường thay đổi. Mối quan hệ giữa đặc tính và lợi nhuận là phi tuyến tính, không cố định và phụ thuộc vào chế độ. Các mô hình tham số áp đặt cấu trúc có thể không phù hợp với thực tế. Bác sĩ đa khoa để dữ liệu lên tiếng.

Chức năng hạt nhân: Mã hóa cấu trúc thị trường

Chức năng hạt nhân $k(x, x')$ là linh hồn của một quá trình Gaussian. Nó xác định hàm nào có thể xảy ra trước bằng cách chỉ định hiệp phương sai giữa các giá trị hàm tại hai điểm đầu vào bất kỳ. Các hạt nhân khác nhau mã hóa các giả định khác nhau về độ mượt, tính tuần hoàn và hành vi tầm xa.

Hàm cơ sở bán kính (RBF) / Hàm mũ bình phương

Hạt nhân RBF là điểm khởi đầu phổ biến nhất:

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

Ở đâu $\sigma^2$ là phương sai tín hiệu (thang đầu ra) và $\ell$ là thang đo chiều dài Các hàm được rút ra từ GP với nhân RBF có khả năng phân biệt vô hạn - rất mượt mà.

Giải thích giao dịch: Thang đo độ dài $\ell$ kiểm soát khoảng cách giữa hai điểm dữ liệu và vẫn có mối tương quan với nhau. Thang đo có độ dài ngắn có nghĩa là mô hình phản ứng với các mẫu cục bộ; thang đo dài có nghĩa là nó nắm bắt được các xu hướng rộng lớn. Phương sai tín hiệu $\sigma^2$ kiểm soát biên độ của hàm - lợi nhuận dự đoán có thể lớn đến mức nào.

Vấn đề về tài chính: Sự trơn tru vô hạn là không thực tế. Lợi nhuận tài chính có những bước nhảy vọt, thay đổi chế độ và sự gián đoạn. Nhân RBF có thể làm mịn hơn các tính năng này, tạo ra các dự đoán quá thận trọng khi gần phá vỡ cấu trúc.

Hạt nhân mẹ

Lớp Matern khái quát hóa RBF bằng cách đưa vào tham số độ mịn $\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)$

Ở đâu $K_{\nu}$ là hàm Bessel sửa đổi loại thứ hai. BẰNG $\nu \to \infty$, hạt nhân Matern hội tụ về RBF. Các lựa chọn phổ biến:

• $\nu = 1/2$: Tương đương với quá trình Ornstein-Uhlenbeck. Các hàm số liên tục nhưng không khả vi - thô, giống như chuyển động Brown.
• $\nu = 3/2$: Các hàm có khả năng một lần. Một sự cân bằng tốt giữa sự êm ái và linh hoạt.
• $\nu = 5/2$: Hàm số có khả vi hai lần. Mượt mà hơn $3/2$ nhưng ít cứng nhắc hơn RBF.

Giải thích giao dịch: The Mother-$3/2$ kernel được cho là mặc định tốt nhất cho chuỗi thời gian tài chính. Nó cho phép loại đường giá thực tế thể hiện sự gồ ghề mà không bị lởm chởm như $\nu = 1/2$. Điều này phù hợp với tài liệu "sự biến động là khó khăn" (Gatheral, Jaisson, & Rosenbaum, 2018), trong đó cho thấy bằng thực nghiệm rằng các đường biến động có số mũ Hurst xung quanh $H \approx 0.1$, mạnh hơn nhiều so với chuyển động Brown.

Bằng chứng chính được công bố cho thấy hạt Matern đánh bại các mô hình biến động cổ điển là Rizvi et al. (2017), người đã báo cáo MSE tốt hơn khoảng 20% ​​so với bước đi ngẫu nhiên và tốt hơn 50% so với GARCH - trên dữ liệu cặp tiền tệ hàng ngày năm 2017, không phải tiền điện tử và không được sao chép ở đây. Hãy coi đó là động lực để dùng thử hạt nhân chứ không phải là điểm chuẩn. GARCH(1,1) của blog này phù hợp với dữ liệu BTC thực hàng ngày, với chẩn đoán Ljung-Box và ARCH-LM, nằm trong dự báo biến động GARCH cho tiền điện tử; đối đầu trực tiếp với GP dành cho bà mẹ trên cùng một mẫu sẽ là sự so sánh trung thực và nó chưa được thực hiện.

Hạt nhân định kỳ

Thị trường tài chính có các mô hình mang tính chu kỳ: đường cong khối lượng trong ngày, hiệu ứng ngày trong tuần, dòng tái cân bằng hàng tháng, mùa thu nhập hàng quý. Hạt nhân định kỳ nắm bắt những điều này:

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

Ở đâu $p$ là thời kỳ. Các hàm rút ra từ hạt nhân này lặp lại theo dấu chấm $p$, được điều chế theo thang đo chiều dài $\ell$ kiểm soát mối tương quan phân rã nhanh như thế nào trong một khoảng thời gian.

Giải thích giao dịch: Đặt $p = 24$ (giờ) để nắm bắt các mẫu hình trong ngày, hoặc $p = 5$ (ngày giao dịch) cho tính thời vụ hàng tuần. Không giống như các tính năng Fourier, hạt nhân định kỳ không giả sử một số lượng sóng hài cố định - GP tìm hiểu hình dạng của chu trình từ dữ liệu.

Kết hợp hạt nhân: Thành phần cộng và nhân

Sức mạnh thực sự của hạt GP nằm ở thành phần. Nếu như $k_1$ Và $k_2$ là các hạt nhân hợp lệ, do đó:

• Tổng: $k_1 + k_2$ — hàm là tổng của các thành phần độc lập (phân rã cộng)
• Sản phẩm: $k_1 \times k_2$ - sự tương tác giữa các thành phần (ví dụ, hành vi định kỳ cục bộ)

Một hạt nhân tổng hợp hữu ích cho lợi nhuận tài chính:

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

Điều này phân hủy tín hiệu thành:

1. Thành phần xu hướng không đều đặn, không định kỳ (Matern-3/2)
2. Là thành phần tuần hoàn có biên độ giảm dần theo thời gian (Tuần hoàn $\times$ RBF)

Sản phẩm $k_{\text{Periodic}} \cdot k_{\text{RBF}}$ tạo ra một hạt nhân định kỳ cục bộ: mẫu lặp lại, nhưng những lần lặp lại ở xa có ít ảnh hưởng hơn những lần lặp lại ở gần. Điều này hoàn toàn đúng đối với tính thời vụ tài chính, vốn thay đổi theo thời gian khi cấu trúc vi mô của thị trường phát triển.

Hạt nhân hỗn hợp quang phổ

Để có độ linh hoạt tối đa, hạt nhân hỗn hợp quang phổ (SM) (Wilson & Adams, 2013) tham số hóa mật độ phổ của hạt nhân dưới dạng hỗn hợp các Gaussian:

$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)$

Ở đâu $w_q$ là trọng lượng hỗn hợp, $v_q$ là phương sai phổ, và $\mu_q$ là phương tiện quang phổ (tần số). Theo định lý Bochner, bất kỳ hạt nhân đứng yên nào cũng có thể được biểu diễn theo cách này. Hạt nhân SM có thể khám phá đồng thời các thành phần định kỳ, xu hướng tầm xa và mối tương quan tầm ngắn - tất cả đều từ dữ liệu.

Giải thích giao dịch: Hạt nhân SM rất hữu ích khi bạn không biết mẫu nào tồn tại trong dữ liệu. Nó có thể xác định các chu kỳ ẩn trong chuỗi lợi nhuận (ví dụ: chu kỳ 4 giờ tinh vi trong thị trường tiền điện tử được thúc đẩy bởi quá trình tái cân bằng tự động). Nhược điểm là có nhiều siêu tham số hơn và nguy cơ trang bị quá mức với các tập dữ liệu nhỏ.

Suy luận sau: Từ trước đến dự đoán

Cho dữ liệu huấn luyện $\mathcal{D} = \{(x_i, y_i)\}_{i=1}^n$ Ở đâu $y_i = f(x_i) + \epsilon_i$ Và $\epsilon_i \sim \mathcal{N}(0, \sigma_n^2)$, GP sau tại các điểm kiểm tra $X_*$ có nghiệm dạng đóng. Đây là lợi thế tính toán chính của GP so với hầu hết các mô hình Bayes.

Phương trình sau

hãy để $K = k(X, X)$ là $n \times n$ ma trận hiệp phương sai đào tạo, $K_* = k(X_*, X)$ là $m \times n$ ma trận hiệp phương sai chéo, và $K_{**} = k(X_*, X_*)$ là $m \times m$ kiểm tra ma trận hiệp phương sai. Phía sau là:

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

Ở đâu:

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

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

Ý nghĩa sau $\bar{f}_*$ là sự kết hợp tuyến tính của các mục tiêu huấn luyện, được tính trọng số bởi độ tương tự của hạt nhân giữa điểm kiểm tra và điểm huấn luyện. Hiệp phương sai sau $\text{Cov}(f_*)$ bắt đầu từ hiệp phương sai trước $K_{**}$ và trừ thông tin thu được từ dữ liệu huấn luyện. Khi dữ liệu huấn luyện dày đặc thì phương sai sau nhỏ. Khi dữ liệu huấn luyện thưa thớt, phương sai sau sẽ trở về phương sai trước.

Khả năng cận biên và Kiểm tra giá trị yêu cầu bồi thường

Siêu tham số hạt nhân $\theta$ (tỷ lệ chiều dài, phương sai, mức nhiễu) được học bằng cách tối đa hóa khả năng cận biên của nhật ký:

$\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$

Thuật ngữ đầu tiên là thuật ngữ phù hợp với dữ liệu (phạt các dự đoán khác xa với các quan sát). Thuật ngữ thứ hai là một hình phạt phức tạp (phạt các mô hình quá linh hoạt - tức là trong đó ma trận hạt nhân có định thức lớn). Số hạng thứ ba là hằng số chuẩn hóa.

Đây là dao cạo Occam tự động và là điều thú vị nhất mà GP mang đến cho hệ thống giao dịch. Phiên bản mạnh mẽ của tuyên bố là không cần bộ xác thực riêng biệt cho việc chính quy hóa - hình phạt phức tạp nằm trong mục tiêu, vì vậy mô hình không thể mua sự phù hợp với tính linh hoạt miễn phí.

Tuyên bố đó đáng bị hoài nghi trên blog này một cách cụ thể. Phân tích cao nguyên cho thấy rằng điểm xác thực một điểm là một tiêu chí lựa chọn tồi và tính chắc chắn đó thể hiện qua hình dạng của vùng lân cận; PBO định lượng tần suất người chiến thắng trong mẫu thua ngoài mẫu; xì hơi Sharpe giá trong số lần thử nghiệm. Khả năng cận biên vẫn là mục tiêu trong mẫu được tối đa hóa trong $\theta$ — hệ số Occam xử phạt mô hình công suất, chứ không phải lựa chọn trên nhiều hạt nhân được trang bị. Nếu bạn chọn được mười hai hạt nhân ứng cử viên và chọn hạt nhân có khả năng cận biên tốt nhất, thì bạn sẽ quay lại lãnh thổ thử nghiệm nhiều lần và logic giảm phát sẽ không thay đổi. Phiên bản có thể giả mạo: lựa chọn khả năng cận biên có tạo ra khoảng cách trong mẫu/ngoài mẫu nhỏ hơn so với lựa chọn tập hợp xác thực trên cùng một dữ liệu và cùng một họ hạt nhân không? Điều đó có thể đo lường được và không được đo lường dưới đây.

Bề mặt khả năng cận biên cũng có tối ưu cục bộ. Khởi động lại ngẫu nhiên nhiều lần hoặc vấn đề khởi tạo cẩn thận - khởi tạo thang đo độ dài theo khoảng cách trung bình theo cặp của các đầu vào huấn luyện và phương sai nhiễu so với phương sai mẫu của mục tiêu là điểm khởi đầu hợp lý.

Chi phí tính toán và khả năng mở rộng

Nút thắt đang đảo ngược $(K + \sigma_n^2 I)$, chi phí nào $O(n^3)$ trong thời gian và $O(n^2)$ trong bộ nhớ. Bức tường khối đã được tranh luận trên blog này theo hướng khác: phương pháp tìm kiếm so với chi phí đánh giá loại bỏ hoàn toàn tối ưu hóa Bayesian dựa trên GP khi mục tiêu rẻ, bởi vì chi phí thay thế cao hơn chi phí đánh giá mà nó tiết kiệm được. Ở đây số học cũng giống như vậy; ứng dụng này là khác nhau. Là một mô hình phù hợp với dữ liệu thị trường, thuật ngữ khối không phải là sự loại bỏ mà là một ngân sách: nó đặt ra một mức trần cứng nhắc cho thời gian đào tạo.

Chiến lược mở rộng cho các ứng dụng giao dịch:

1. GP thưa thớt (điểm cảm ứng). Thay thế $n \times n$ ma trận với một $m \times m$ ma trận ở đâu $m \ll n$. Những điểm kích thích $Z = \{z_1, \ldots, z_m\}$ là các đầu vào giả tóm tắt dữ liệu huấn luyện. Công thức SVGP (Stochastic Varial GP) của Hensman et al. (2013) cho phép đào tạo theo đợt nhỏ với chi phí $O(nm^2)$ mỗi lần lặp. GPyTorch hỗ trợ điều này một cách tự nhiên.

2. Nội suy hạt nhân có cấu trúc (SKI/KISS-GP). Khai thác cấu trúc Kronecker và Toeplitz trong ma trận hạt nhân khi đầu vào nằm trên lưới. Giảm chi phí để $O(n + g \log g)$ Ở đâu $g$ là kích thước lưới. Lý tưởng cho chuỗi thời gian được lấy mẫu thường xuyên (ví dụ: thanh 1 phút).

3. GP cục bộ trên cửa sổ trượt. Chỉ đào tạo các GP riêng biệt dựa trên dữ liệu gần đây. Đây là nơi mà ràng buộc dành riêng cho GP bị ảnh hưởng: các hạt nhân tiêu chuẩn đứng yên ($k(x,x')$ chỉ phụ thuộc vào $x - x'$) còn thị trường thì không, vì vậy câu trả lời thông thường là cửa sổ cuộn - nhưng độ dài cửa sổ được giới hạn phía trên bởi $O(n^3)$, không chỉ bằng số liệu thống kê. Tối ưu hóa chuyển tiếp bao gồm cửa sổ cố định và cửa sổ cuộn, thời lượng đào tạo/kiểm tra và tần suất tối ưu hóa lại nói chung; đối với GP, việc định cỡ cửa sổ là một quyết định tính toán giống như quyết định thống kê và cửa sổ cố định (ngày càng phát triển) đơn giản là không khả dụng nếu vượt quá vài nghìn điểm mà không có giá trị gần đúng. Việc điều chỉnh lại đó là hệ quả thực tế: với bác sĩ đa khoa, bạn không được chọn "sử dụng tất cả lịch sử".

GP để dự đoán lợi nhuận: Khung thực tế

Thiết kế tính năng: Tại sao 5-20 tính năng chứ không phải 500

Phân loại tính năng chung cho ML dữ liệu thị trường — mất cân bằng sổ đặt hàng, áp lực sổ sách, VPIN, lambda của Kyle, các tính năng biến động nhận ra, mã hóa thời gian theo chu kỳ, tín hiệu tài sản chéo và tỷ lệ cấp vốn — đã được trình bày trong mô hình trải rộng với học máy; sử dụng danh sách đó.

GP cụ thể là kích thước của danh sách. Các phương thức hạt nhân bị suy giảm ở các chiều cao: khoảng cách tập trung và hạt nhân cố định mất khả năng phân biệt đối xử. Phạm vi thực tế cho một GP tài chính là 5-20 đầu vào, không phải hàng trăm đầu vào mà cây được tăng cường độ dốc vui vẻ ăn. Cơ chế giúp điều này có thể tồn tại được là ARD (Xác định mức độ liên quan tự động): cung cấp cho mỗi thứ nguyên đầu vào thang độ dài riêng $\ell_d$, và đào tạo có khả năng cận biên thúc đẩy $\ell_d \to \infty$ đối với các kích thước không mang tín hiệu, vì thang đo độ dài vô hạn có nghĩa là hạt nhân bỏ qua tọa độ đó. Việc lựa chọn tính năng trở thành sản phẩm phụ của việc điều chỉnh, và những gì đã học được $\ell_d$ có thể đọc trực tiếp dưới dạng xếp hạng mức độ liên quan - đây cũng là điều khiến nó có thể bị giả mạo: khớp hạt nhân tổng hợp trên các thanh thực, in thang đo chiều dài và xem liệu các đặc điểm mà bạn tin tưởng có phải là đặc điểm mà mô hình lưu giữ hay không.

Định cỡ vị trí và bỏ qua

GP sau cho $\sigma_*(x)$ trực tiếp, do đó, nó rơi thẳng vào bộ lọc định cỡ tỷ lệ cạnh và cấm giao dịch được phát triển trong Dự đoán phù hợp cho định cỡ vị thế nhận biết rủi ro, với độ rộng khoảng $w_t = 2\kappa\sigma_*(x)$. Sự khác biệt duy nhất là xuất xứ: GP tạo ra chiều rộng từ chính mô hình chứ không phải từ bộ hiệu chuẩn, do đó, nó thay đổi theo vị trí của điểm kiểm tra so với dữ liệu huấn luyện thay vì với lượng tử toàn cầu của phần dư trong quá khứ.

Triển khai với GPyTorch

GPyTorch là thư viện dựa trên PyTorch để suy luận GP có thể mở rộng. Nó thúc đẩy khả năng tăng tốc GPU, vi phân tự động và các kỹ thuật đại số tuyến tính hiện đại (gradient liên hợp, phân rã Lanczos) để mở rộng quy mô GP vượt ra ngoài khuôn khổ ngây thơ $O(n^3)$ giới hạn.

GP chính xác cơ bản để dự đoán lợi nhuận

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 là những gì cho phép thang đo độ dài theo kích thước được thảo luận ở trên. Sau khi đào tạo, model.covar_matern.base_kernel.lengthscale là vector để đọc ra.

Vòng đào tạo

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

Dự đoán không chắc chắn

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(),
    }

các fast_pred_var() trình quản lý bối cảnh sử dụng thuật toán LOVE (Ước tính phương sai Lanczos) để tính toán các phương sai dự đoán trong $O(n)$ thời gian thay vì $O(n^2)$.

Đường ống giao dịch từ đầu đến cuối

Lưu ý về trình tạo tính năng bên dưới: mọi số liệu thống kê luân phiên phải được xem ngược một cách nghiêm ngặt và tiêu chuẩn hóa đầu vào phải chỉ được trang bị trên phần đào tạo. Điểm thứ hai đó không phải là vấn đề chung chung — đó chính xác là kênh rò rỉ chuẩn hóa được mổ xẻ và đo lường trong phân loại thiên vị nhìn về phía trước, báo cáo lạm phát Sharpe mà mỗi loại rò rỉ tạo ra. GP tiêu chuẩn hóa đầu vào của mình theo cấu trúc, vì vậy đây là điểm rò rỉ mà nó dễ gặp phải nhất.

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

Mở rộng quy mô sang các tập dữ liệu lớn hơn với GP thưa thớt

Khi cửa sổ đào tạo vượt quá vài nghìn điểm, suy luận GP chính xác sẽ trở nên chậm. Chuyển sang GP thưa thớt khác nhau:

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

Với 128 điểm cảm ứng, chi phí cho mỗi đợt là $O(128^2 \times \text{batch\_size})$ - khoảng 4 triệu hoạt động mỗi đợt. Điều này dễ dàng xử lý các bộ dữ liệu gồm hơn 100.000 quan sát trên một GPU.

Deep Kernel Learning: GP đáp ứng mạng lưới thần kinh

Khi không gian đầu vào có nhiều chiều hoặc mối quan hệ giữa các tính năng và kết quả trả về rất phi tuyến tính, một hạt nhân đơn giản có thể gặp khó khăn. Học hạt nhân sâu (DKL) chuyển đầu vào qua mạng thần kinh trước khi áp dụng hạt nhân GP:

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

Ở đâu $g_\phi$ là một mạng lưới thần kinh với các tham số $\phi$ Và $k_{\text{base}}$ là hạt nhân tiêu chuẩn (ví dụ: Matern-3/2). Mạng học cách biểu diễn tính năng trong đó nhân GP hoạt động hiệu quả nhất. Toàn bộ mô hình — tham số mạng và siêu tham số hạt nhân — được đào tạo từ đầu đến cuối bằng cách tối đa hóa khả năng cận biên.

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 kết hợp việc học biểu diễn của mạng lưới thần kinh với việc định lượng độ không đảm bảo của GP. Lớp GP đảm bảo rằng các dự đoán ở xa dữ liệu huấn luyện có độ không chắc chắn cao - điều mà các mạng thần kinh tiêu chuẩn nổi tiếng không cung cấp được. Cũng lưu ý rằng DKL giới thiệu lại chính xác tính linh hoạt mà khả năng cận biên được cho là dành cho cảnh sát: hệ số Occam phạt hạt nhân, nhưng mạng phía trước nó có hàng nghìn tham số miễn phí và không có hình phạt nào như vậy.

Ludkovski và Risk (2025), Mô hình quy trình Gaussian cho tài chính định lượng, khảo sát DKL trong bối cảnh tài chính định lượng rộng hơn bao gồm định giá quyền chọn và tối ưu hóa danh mục đầu tư; những kết quả đó là của họ, về vấn đề của họ và không phải là bằng chứng về dự đoán lợi nhuận của tiền điện tử.

Chẩn đoán và cạm bẫy

Hiệu chuẩn

GP được hiệu chỉnh tốt có khoảng thời gian dự đoán phù hợp với phạm vi thực nghiệm. Kiểm tra này cũng giống như kiểm tra được sử dụng trong dự đoán tuân thủ — cũng bao gồm lý thuyết về lý do tại sao phạm vi bảo hiểm cận biên không phải là phạm vi bảo hiểm có điều kiện, một hạn chế cũng áp dụng cho các khoảng 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}"
        )

Mức vượt dự kiến ​​là 0,317 / 0,046 / 0,003 ở 1/2/3 sigma. Con số quan trọng là những gì nó in ra trong quá trình chạy từng bước thực sự trên các thanh tiền điện tử và bảng đó vẫn chưa có trong bài viết này. Kỳ vọng trước đó là GP quá tự tin - khả năng Gaussian đối với lợi nhuận không ổn định, không cố định sẽ có mức che phủ kém ở mức 3 sigma - nhưng "nên" không phải là một phép đo.

Những cạm bẫy còn lại

1. Tỷ lệ đầu vào. Tỷ lệ chiều dài có liên quan đến tỷ lệ đầu vào, do đó, một tính năng sẽ có phạm vi $[0, 10000]$ và một người tầm xa $[0, 1]$ không thể chia sẻ ý nghĩa $\ell$; ARD là thứ giải quyết các phạm vi không đồng nhất và tiêu chuẩn hóa là thứ giúp cho việc khởi tạo ARD trở nên hợp lý.

2. Khớp quá mức khả năng cận biên. Với nhiều siêu tham số hạt nhân (đặc biệt là hạt nhân tổng hợp hoặc hỗn hợp quang phổ), khả năng cận biên vẫn có thể phù hợp quá mức. Sử dụng mức ưu tiên: mức log-bình thường trước về thang đo chiều dài tập trung ở khoảng cách trung bình theo cặp, mức nửa bình thường trước về phương sai.

3. Điều hòa ma trận hiệp phương sai. $(K + \sigma_n^2 I)$ có thể trở thành số ít khi tiếng ồn $\sigma_n^2$ quá nhỏ hoặc khi điểm huấn luyện gần như bị trùng lặp. GPyTorch cho biết thêm $10^{-6}$ jitter theo đường chéo; dữ liệu tài chính được điều chỉnh kém thường cần nhiều hơn.

4. Thành kiến ​​nhìn về phía trước. Đã đề cập ở trên và được đo lường chi tiết trong phân loại thành kiến ​​nhìn về phía trước.

Khi nào nên sử dụng GP so với các mẫu xe khác

* Đối với các cột XGBoost và mạng thần kinh, hãy tuân theo các so sánh đã công bố thay vì khẳng định mới ở đây: mô hình trải rộng với học máy có bảng tăng cường độ dốc so với học sâu cho dữ liệu dạng bảng tài chính (ngưỡng kích thước dữ liệu, khả năng diễn giải, thích ứng chế độ, độ trễ) và bộ biến đổi nhiệt hạch tạm thời có TFT so với LSTM so với máy biến áp vani.

Sử dụng GP khi:

• Bạn có bộ dữ liệu vừa và nhỏ (dưới ~10.000 quan sát mỗi cửa sổ đào tạo)
• Bạn muốn có một giả thuyết cấu trúc rõ ràng, có thể kiểm tra được về tín hiệu (xu hướng + tính thời vụ + nhiễu)
• Độ không đảm bảo phải thay đổi theo khoảng cách từ dữ liệu huấn luyện, không chỉ với lượng tử dư toàn cầu

Không sử dụng GP khi:

• Bạn cần suy luận dưới một phần nghìn giây trên hàng triệu quan sát
• Kích thước đầu vào vượt quá ~50
• Tín hiệu tồn tại trong các tương tác tính năng bậc cao phức tạp mà các hạt nhân cố định không thể biểu diễn (DKL trợ giúp, với chi phí là thuộc tính Occam)

Bài viết này chưa đo lường được điều gì

Tất cả mọi thứ ở trên là máy móc mô hình. Không có bằng chứng nào cho thấy GP kiếm tiền từ tiền điện tử và tiêu chuẩn của blog này là bài viết mang những con số riêng. Các mục đang mở, theo thứ tự chúng sẽ được chạy:

1. Tỷ lệ chiều dài ARD trên thanh BTCUSDT 1m thực. Lắp hạt nhân tổng hợp, in $\ell_d$ mỗi tính năng. Điều này trực tiếp kiểm tra tuyên bố "ARD là lựa chọn tính năng tích hợp sẵn" và tạo ra thứ hạng có thể làm sai lệch mức độ liên quan của tính năng.
2. Bảng hiệu chuẩn từ một lần chạy tiến. Vượt quá dự kiến so với thực nghiệm ở mức 1/2/3 sigma, được nêu rõ ràng, bao gồm cả trường hợp GP hóa ra quá tự tin.
3. Chiến lược kiểm soát sự tự tin, tiến về phía trước, trên cùng năm chuyên ngành với tiêu cực trung thực, giảm phát cho số lần dùng thử. Nếu thất bại, nó sẽ xếp vào chuỗi đó dưới dạng một kết quả tiêu cực khác.
4. Đồng hồ treo tường $O(n^3)$ đường cong cho $n = 250 / 500 / 1000 / 2000 / 5000$, chính xác so với SVGP, do đó phần khả năng mở rộng nằm trên biểu đồ thay vì xác nhận.

Kết luận

Trường hợp của các quy trình Gaussian trong giao dịch không phải là "chúng cung cấp cho bạn các thanh lỗi" - dự đoán phù hợp cung cấp cho bạn các thanh lỗi với ít giả định phân phối hơn và đảm bảo phạm vi bảo hiểm mà GP không có. Trường hợp là GP yêu cầu bạn viết giả thuyết cấu trúc của mình xuống dưới dạng hạt nhân, làm cho nó phù hợp với mục tiêu đánh giá mức độ phức tạp của chính nó và sau đó cho bạn biết tính năng nào của bạn mà nó thực sự được sử dụng thông qua thang đo độ dài ARD. Đó là một mô hình dễ đọc khác thường.

Các chi phí đều cụ thể như nhau: chia tỷ lệ khối làm giới hạn cửa sổ đào tạo của bạn, giả định về tính dừng mà cửa sổ cuộn chỉ sửa chữa một phần, khả năng Gaussian mà lợi nhuận ngắn hạn sẽ vi phạm và - một khi bạn đạt đến khả năng học tập sâu trong hạt nhân - sự mất mát thầm lặng của chính thuộc tính Occam đã thúc đẩy khả năng cận biên ngay từ đầu. Liệu những gì còn lại có thể giao dịch được hay không là một câu hỏi thực nghiệm, và bốn phép đo được liệt kê ở trên là những gì sẽ trả lời câu hỏi đó.

Tài liệu tham khảo

• Rasmussen, C. E., & Williams, C. K. I. (2006). Quy trình Gaussian cho học máy. Báo chí MIT.
• Wilson, A., & Adams, R. (2013). Hạt nhân quy trình Gaussian để khám phá mẫu và ngoại suy. ICML.
• Hensman, J., Fusi, N., & Lawrence, N. D. (2013). Quy trình Gaussian cho dữ liệu lớn. UAI.
• Gatheral, J., Jaisson, T., & Rosenbaum, M. (2018). Sự biến động là thô. Tài chính định lượng, 18(6).
• Rizvi, S. A. A., Roberts, S. J., Osborne, M. A., & Nyikosa, F. (2017). Một cách tiếp cận mới để dự báo biến động tài chính với các đường bao quy trình Gaussian. arXiv:1705.00891.
• Ludkovski, M., & Risk, J. (2025). Mô hình quy trình Gaussian cho tài chính định lượng. Mùa xuân.
• Gardner, J. R., Pleiss, G., Bindel, D., Weinberger, K. Q., & Wilson, A. G. (2018). GPyTorch: Suy luận quy trình Gaussian ma trận hộp đen với khả năng tăng tốc GPU. NeurIPS.