Parametrik Olmayan Fiyat Modellemesi için Gauss Süreçleri

"Klasik ML temelleri" serisinin bir parçası.

Gauss sürecini bu blogda ayrı bir makaleye değer kılan iki şey vardır ve bunların hiçbiri "size belirsizlik vermez."

Bunlardan ilki çekirdek tasarımı. Bir pratisyen hekimin tüm endüktif önyargısı tek bir işlevde yaşar $k(x, x')$ve bu işlev bilinçli olarak yazdığınız bir şeydir: yolun ne kadar zorlu olduğu, tekrarlanıp tekrarlanmadığı, tekrarın bozulup bozulmadığı. Standart araç setindeki başka hiçbir şey, piyasa dinamikleri hakkında açıkça ve daha sonra ona uyan yapısal bir hipotez belirtmenize izin vermez. İkincisi marjinal olasılık'tır; karmaşıklık cezasının uzatılmış bir kümeden değil, modelin kendisinden türetildiği bir eğitim hedefidir. Bu blogdaki aşırı uyum yayındaki diğer tüm makaleler (platau analizi, PBO, deflated Sharpe) mevcuttur çünkü doğrulama seti düzenlemesi arama sırasında hassastır. Bir pratisyen hekim buna ihtiyaç duymadığını iddia ediyor. Bu iddia test edilebilir ve bunu test etmek, başka bir belirsizliği boyutlandırma eğitiminden daha ilginçtir.

Belirsizliğin kendisi hakkında: GP sonsal varyansı yapısaldır - daha sonra uygun bir modelin etrafına sarılmak yerine, ortalamayı üreten aynı çıkarımdan kaynaklanır. Bu, bu blogda belirsizliğin konum boyutlandırma için neden doğru girdi olduğunu ve bir aralığa sahip olduğunuzda bir aralıkla ne yapmanız gerektiğini zaten kapsayan uygun tahmin ile gerçek zıtlıktır. Bu makale bu durumu yeniden tartışmıyor; modelin peşinden gider.

Aşağıda çekirdek ve çıkarım makinesi, GPyTorch uygulaması ve -sonunda açıkça belirtildiği üzere- bu makalenin henüz sahip olmadığı ölçümler yer almaktadır.

Gauss Süreci Nedir?

Pratisyen hekimler zaten bu blogda aynı notasyon ve aynı düşük boyutluluk uyarısıyla Optuna vs. koordinat inişinde Bayes optimizasyonunun vekili olarak görünüyor. Burada GP, hiperparametre arama yüzeyi yerine pazar verilerine uygun modelin kendisidir, dolayısıyla tedavi daha derine iner.

Gauss süreci, herhangi bir sonlu sayıda ortak Gauss dağılımına sahip olan rastgele değişkenlerin bir koleksiyonudur. Bu, parametreler üzerinden bir dağılım değil, fonksiyonlar üzerinden bir dağılımdır.

Biçimsel olarak bir işlev $f: \mathcal{X} \to \mathbb{R}$ herhangi bir sonlu girdi kümesi için GP'den alınır $\{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)$

Neresi $m(x) = \mathbb{E}[f(x)]$ ortalama fonksiyonudur ve $k(x, x') = \text{Cov}(f(x), f(x'))$ kovaryans (çekirdek) fonksiyonudur. Bunu kısaca şu şekilde yazıyoruz:

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

Ortalama işlevi, ortalama davranışa ilişkin ön inancı kodlar. $f$. Ticarette genellikle belirliyoruz $m(x) = 0$, getiriler üzerinde önceden yönsel bir önyargımızın olmadığı varsayımını kodluyor. Tüm yapı çekirdeğe gider.

Neden Parametrik Olmayan?

5 özelliğe sahip bir doğrusal regresyon modelinin 6 parametresi vardır. 64 birimden oluşan iki gizli katmanı olan bir sinir ağında binlerce birim bulunur. Bir GP'nin sabit sayıda parametresi yoktur; modelin karmaşıklığı verilerle birlikte artar. 10 gözlemle GP, 10 boyutlu bir Gaussian'ı tanımlar. 10.000 gözlemle 10.000 boyutlu bir Gaussian'ı tanımlar.

Bu, pratisyen hekimlerin hiperparametreleri olmadığı anlamına gelmez. Çekirdek fonksiyonu, öncekinden alınan fonksiyonların özelliklerini kontrol eden hiper parametrelere (uzunluk ölçekleri, genlikler, periyodiklikler) sahiptir. Ancak işlevsel formun kendisi asla sabitlenmez. GP, yeterli veri ve doğru çekirdek verildiğinde herhangi bir sürekli fonksiyonu temsil edebilir. "Parametrik olmayan"ın anlamı budur; model, doğrusal fonksiyonlar veya polinomlar gibi parametrik bir aileyle sınırlı değildir.

Finansal modelleme açısından bu değerlidir. Piyasalar değişir. Özellikler ve getiriler arasındaki ilişki doğrusal değildir, durağan değildir ve rejime bağımlıdır. Parametrik modeller gerçeklikle eşleşmeyebilecek bir yapı empoze eder. Pratisyen hekimler verilerin konuşmasına izin verir.

Çekirdek İşlevleri: Pazar Yapısını Kodlama

Çekirdek işlevi $k(x, x')$ Gauss sürecinin ruhudur. Herhangi iki giriş noktasındaki fonksiyon değerleri arasındaki kovaryansı belirterek hangi fonksiyonların olası olduğunu önceden tanımlar. Farklı çekirdekler düzgünlük, periyodiklik ve uzun vadeli davranışla ilgili farklı varsayımları kodlar.

Radyal Temel Fonksiyon (RBF) / Kare Üstel

RBF çekirdeği en yaygın başlangıç noktasıdır:

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

Neresi $\sigma^2$ sinyal varyansı (çıkış ölçeği) ve $\ell$ uzunluk ölçeğidir. RBF çekirdeğine sahip bir GP'den alınan işlevler sonsuz şekilde türevlenebilir - çok düzgün.

Ticaret yorumu: Uzunluk ölçeği $\ell$ iki veri noktasının ne kadar uzakta olabileceğini ve hala ilişkilendirilebileceğini kontrol eder. Kısa uzunluk ölçeği, modelin yerel kalıplara tepki verdiği anlamına gelir; uzun uzunluk ölçeği geniş eğilimleri yakaladığı anlamına gelir. Sinyal varyansı $\sigma^2$ fonksiyonun genliğini (tahmin edilen getirilerin ne kadar büyük olabileceğini) kontrol eder.

Finans sorunu: Sonsuz pürüzsüzlük gerçekçi değildir. Finansal getirilerde sıçramalar, rejim değişiklikleri ve süreksizlikler var. RBF çekirdeği bu özellikleri abartabilir ve yapısal kırılmalar yakınında fazla ihtiyatlı tahminler üretebilir.

Ana Çekirdek

Matern sınıfı, bir düzgünlük parametresi sunarak RBF'yi genelleştirir. $\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)$

Neresi $K_{\nu}$ ikinci türden değiştirilmiş Bessel fonksiyonudur. Gibi $\nu \to \infty$, Matern çekirdeği RBF'ye yakınsar. Ortak seçimler:

• $\nu = 1/2$: Ornstein-Uhlenbeck sürecine eşdeğerdir. Fonksiyonlar süreklidir ancak türevlenemez — kabaca, Brown hareketi gibi.
• $\nu = 3/2$: Fonksiyonlar bir kez türevlenebilir. Pürüzsüzlük ve esneklik arasında iyi bir denge.
• $\nu = 5/2$: Fonksiyonlar iki kez türevlenebilir. Şundan daha yumuşak: $3/2$ ancak RBF'den daha az katıdır.

Ticaret yorumu: The Matern-$3/2$ çekirdek, finansal zaman serileri için tartışmasız en iyi varsayılandır. Gerçek fiyat yollarının sergilediği pürüzlülüğe, $\nu = 1/2$. Bu, volatilite yollarının etrafında Hurst üslerinin bulunduğunu ampirik olarak gösteren "volatilite kabadır" literatürüyle (Gatheral, Jaisson ve Rosenbaum, 2018) uyumludur. $H \approx 0.1$Brownian hareketinden çok daha pürüzlüdür.

Matern çekirdeklerinin klasik oynaklık modellerini geride bıraktığına dair yayınlanmış ana kanıt Rizvi ve ark. (2017), MSE'nin rastgele yürüyüşe göre kabaca %20 ve GARCH'a göre %50 daha iyi olduğunu bildirmiştir — 2017 günlük döviz çifti verilerine göre, kripto değil ve burada belirtilmemiştir. Bunu bir kıyaslama olarak değil, çekirdeği denemek için bir motivasyon olarak değerlendirin. Bu blogun kendi GARCH(1,1)'i, Ljung-Box ve ARCH-LM teşhisleriyle birlikte gerçek BTC günlük verilerine uygundur ve kripto için GARCH oynaklık tahmininde; Aynı örnek üzerinde Matern GP ile kafa kafaya bir karşılaştırma dürüst bir karşılaştırma olacaktır ve henüz yapılmadı.

Periyodik Çekirdek

Finansal piyasaların döngüsel modelleri vardır: gün içi hacim eğrileri, haftanın günü etkileri, aylık yeniden dengelenme akışları, üç aylık kazanç dönemleri. Periyodik çekirdek şunları yakalar:

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

Neresi $p$ dönemdir. Bu çekirdekten alınan işlevler nokta ile tekrarlanır $p$uzunluk ölçeğiyle modüle edilmiş $\ell$ korelasyonun bir dönem içinde ne kadar hızlı bozulduğunu kontrol eder.

Ticaret yorumu: Ayarla $p = 24$ (saat) gün içi kalıpları yakalamak için veya $p = 5$ (işlem günleri) haftalık mevsimsellik için. Fourier özelliklerinden farklı olarak periyodik çekirdek, sabit sayıda harmonik varsaymaz; GP, döngünün şeklini verilerden öğrenir.

Çekirdekleri Birleştirmek: Toplamalı ve Çarpımsal Kompozisyon

GP çekirdeklerinin gerçek gücü kompozisyonda yatmaktadır. Eğer $k_1$ Ve $k_2$ geçerli çekirdeklerdir, yani:

• Toplam: $k_1 + k_2$ — fonksiyon bağımsız bileşenlerin toplamıdır (toplamsal ayrışma)
• Ürün: $k_1 \times k_2$ — bileşenler arasındaki etkileşimler (örneğin, yerel periyodik davranış)

Finansal getiriler için yararlı bir bileşik çekirdek:

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

Bu, sinyali şu şekilde ayrıştırır:

1. Pürüzsüz olmayan, periyodik olmayan bir trend bileşeni (Matern-3/2)
2. Genliği zamanla azalan periyodik bir bileşen (Periyodik $\times$ RBF)

Ürün $k_{\text{Periodic}} \cdot k_{\text{RBF}}$ yerel olarak periyodik bir çekirdek oluşturur: model tekrarlanır, ancak uzak tekrarların yakındakilere göre daha az etkisi vardır. Bu, piyasanın mikro yapısı geliştikçe zamanla kayan finansal mevsimsellik için tamamen doğrudur.

Spektral Karışım Çekirdekleri

Maksimum esneklik için, spektral karışım (SM) çekirdeği (Wilson ve Adams, 2013), çekirdeğin spektral yoğunluğunu Gaussianların bir karışımı olarak parametreleştirir:

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

Neresi $w_q$ karışım ağırlıklarıdır, $v_q$ spektral varyanslardır ve $\mu_q$ spektral araçlardır (frekanslar). Bochner teoremine göre herhangi bir sabit çekirdek bu şekilde temsil edilebilir. SM çekirdeği, periyodik bileşenleri, uzun vadeli eğilimleri ve kısa vadeli korelasyonları eş zamanlı olarak verilerden keşfedebilir.

Ticaret yorumu: SM çekirdeği, verilerde hangi kalıpların mevcut olduğunu bilmediğiniz durumlarda kullanışlıdır. Dönüş serilerindeki gizli periyodiklikleri (örneğin, otomatik yeniden dengelemenin yönlendirdiği kripto pazarlarındaki 4 saatlik ince döngüler) tanımlayabilir. Dezavantajı ise daha fazla hiper parametre ve küçük veri kümelerine aşırı uyum riskidir.

Arka Çıkarım: Öncesinden Tahmine

Verilen eğitim verileri $\mathcal{D} = \{(x_i, y_i)\}_{i=1}^n$ Neresi $y_i = f(x_i) + \epsilon_i$ Ve $\epsilon_i \sim \mathcal{N}(0, \sigma_n^2)$, test noktalarında GP posterior $X_*$ kapalı form çözümü vardır. Bu, GP'lerin Bayes modellerinin çoğuna göre temel hesaplama avantajıdır.

Arka Denklemler

izin ver $K = k(X, X)$ olmak $n \times n$ eğitim kovaryans matrisi, $K_* = k(X_*, X)$ olmak $m \times n$ çapraz kovaryans matrisi ve $K_{**} = k(X_*, X_*)$ olmak $m \times m$ kovaryans matrisini test edin. Arkası ise:

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

Neresi:

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

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

Arka ortalama $\bar{f}_*$ test ve eğitim noktaları arasındaki çekirdek benzerliğine göre ağırlıklandırılan eğitim hedeflerinin doğrusal bir birleşimidir. Arka kovaryans $\text{Cov}(f_*)$ önceki kovaryanstan başlar $K_{**}$ ve elde edilen bilgiyi eğitim verisinden çıkarır. Eğitim verilerinin yoğun olduğu durumlarda sonsal varyans küçüktür. Eğitim verilerinin seyrek olduğu durumlarda son varyans önceki varyansa geri döner.

Marjinal Olasılık ve Test Edilmeye Değer İddia

Çekirdek hiperparametreleri $\theta$ (uzunluk ölçekleri, varyanslar, gürültü seviyesi), log marjinal olasılığının maksimuma çıkarılmasıyla öğrenilir:

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

İlk terim veriye uygun bir terimdir (gözlemlerden uzak tahminleri cezalandırır). İkinci terim karmaşıklık cezasıdır (çok esnek olan modelleri, yani çekirdek matrisinin büyük belirleyiciye sahip olduğu modelleri cezalandırır). Üçüncü terim bir normalleştirme sabitidir.

Bu otomatik Occam'ın jiletidir ve bir pratisyen hekimin ticaret hattına getirdiği en ilginç şeydir. İddianın güçlü versiyonu, düzenlileştirme için ayrı bir doğrulama setine gerek olmadığıdır — karmaşıklık cezası hedefin içindedir, dolayısıyla model, esneklikle uyumu ücretsiz olarak satın alamaz.

Bu iddia özellikle bu blogda şüpheciliği hak ediyor. Plateau analizi, tek noktalı doğrulama puanının kötü bir seçim kriteri olduğunu ve sağlamlığın mahalle şeklinde yaşadığını gösterir; PBO, örnek içindeki kazananın örnek dışında ne sıklıkta kaybettiğini ölçer; deneme sayısındaki deflated Sharpe fiyatları. Marjinal olasılık hâlâ maksimuma çıkarılan örnek içi bir hedeftir $\theta$ — Occam faktörü, birçok çekirdek arasından seçim yapmayı değil, model kapasitesini cezalandırır. On iki aday çekirdeği yerleştirir ve en iyi marjinal olasılığa sahip olanı seçerseniz, çoklu test alanına geri dönersiniz ve deflasyon mantığı değişmeden uygulanır. Yanlışlanabilir versiyon: marjinal olasılık seçimi, aynı veriler ve aynı çekirdek ailesi üzerinde doğrulama seti seçiminden daha küçük bir örnek içi/örnek dışı boşluk üretir mi? Bu ölçülebilirdir ve aşağıda ölçülmez.

Marjinal olabilirlik yüzeyi aynı zamanda yerel optimuma da sahiptir. Çoklu rastgele yeniden başlatmalar veya dikkatli başlatma meselesi - uzunluk ölçeğini eğitim girdilerinin ortanca ikili mesafesine ve gürültü varyansını hedeflerin örnek varyansına göre başlatmak makul bir başlangıç ​​noktasıdır.

Hesaplamalı Maliyet ve Ölçeklenebilirlik

Darboğaz tersine dönüyor $(K + \sigma_n^2 I)$, maliyeti $O(n^3)$ zamanında ve $O(n^2)$ hafızada. Kübik duvar bu blogda zaten diğer yönden tartışılıyor: arama yöntemi ve değerlendirme maliyeti, amaç ucuz olduğunda GP tabanlı Bayesian optimizasyonunu doğrudan diskalifiye eder, çünkü yedek maliyet, kaydettiği değerlendirmelerden daha fazladır. Aritmetik burada da aynı; uygulama farklıdır. Piyasa verilerine uygun bir model olarak kübik terim bir diskalifiye değil, bir bütçedir: eğitim penceresinde sert bir tavan belirler.

Ticaret uygulamaları için ölçeklenebilirlik stratejileri:

1. Seyrek GP'ler (tetikleyici noktalar). Değiştirin $n \times n$ bir matris $m \times m$ matris nerede $m \ll n$. Uyarıcı noktalar $Z = \{z_1, \ldots, z_m\}$ eğitim verilerini özetleyen sözde girdilerdir. Hensman ve arkadaşlarının SVGP (Stokastik Değişken GP) formülasyonu. (2013) maliyetle birlikte mini toplu eğitime izin veriyor $O(nm^2)$ yineleme başına. GPyTorch bunu yerel olarak destekler.

2. Yapılandırılmış çekirdek enterpolasyonu (SKI/KISS-GP). Girişler bir ızgara üzerinde yer aldığında çekirdek matrisindeki Kronecker ve Toeplitz yapısından yararlanır. Maliyeti azaltır $O(n + g \log g)$ Neresi $g$ ızgara boyutudur. Düzenli olarak örneklenen zaman serileri (ör. 1 dakikalık çubuklar) için idealdir.

3. Yerel pratisyen hekimler sürgülü pencerelerde. Ayrı pratisyen hekimleri yalnızca en son verilerle eğitin. GP'ye özgü kısıtlamanın devreye girdiği yer burasıdır: standart çekirdekler sabittir ($k(x,x')$ sadece bağlıdır $x - x'$) ve piyasalar öyle değil, bu nedenle genel cevap kayan penceredir - ancak pencere uzunluğu yukarıdan sınırlanmıştır $O(n^3)$sadece istatistiklerle değil. İleriye doğru optimizasyon genel olarak bağlantılı ve hareketli pencereleri, eğitim/test uzunluklarını ve yeniden optimizasyon sıklığını kapsar; Bir pratisyen hekim için pencere boyutlandırma, istatistiksel olduğu kadar bir hesaplama kararıdır ve bağlantılı (sürekli büyüyen) bir pencere, yaklaşık değer olmadan birkaç bin noktadan sonra kullanılamaz. Bu yeniden çerçeveleme pratik sonuçtur: GP'lerde "tüm geçmişi kullan" seçeneğini seçemezsiniz.

Geri Dönüş Tahmini için GP: Pratik Bir Çerçeve

Özellik Tasarımı: Neden 500 Değil, 5-20 Özellik

Piyasa verileri makine öğreniminin genel özellik sınıflandırması (sipariş defteri dengesizliği, defter baskısı, VPIN, Kyle'ın lambdası, gerçekleşen volatilite özellikleri, döngüsel zaman kodlaması, çapraz varlıklar ve fonlama oranı sinyalleri) makine öğrenimiyle yayılma modellemesi bölümünde zaten ortaya konmuştur; o listeyi kullan.

GP'ye özgü olan listenin boyutudur. Çekirdek yöntemleri yüksek boyutlarda bozulur: mesafeler yoğunlaşır ve sabit bir çekirdek ayrımcılığı kaybeder. Bir mali pratisyen hekim için pratik aralık 5-20 girdidir; eğimle güçlendirilmiş bir ağacın mutlu bir şekilde yediği yüzlerce girdi değil. Bunu sürdürülebilir kılan mekanizma ARD'dir (Otomatik Uygunluk Belirleme): her giriş boyutuna kendi uzunluk ölçeğini verin $\ell_d$ve marjinal olasılık eğitimi iter $\ell_d \to \infty$ sinyal taşımayan boyutlar için, çünkü sonsuz uzunluk ölçeği, çekirdeğin bu koordinatı göz ardı ettiği anlamına gelir. Özellik seçimi, uyum sağlamanın bir yan ürünü haline gelir ve öğrenilenler $\ell_d$ doğrudan bir ilgi sıralaması olarak okunabilir - bu aynı zamanda onu yanlışlanabilir kılan da şeydir: bileşik çekirdeği gerçek çubuklara yerleştirin, uzunluk ölçeklerini yazdırın ve inandığınız özelliklerin modelin koruduğu özellikler olup olmadığına bakın.

Pozisyon Belirleme ve Çekimserlik

GP arka verir $\sigma_*(x)$ doğrudan, aralık genişliğiyle doğrudan Riske Duyarlı Pozisyon Boyutlandırması için Uyumlu Tahmin bölümünde geliştirilen kenar oranı boyutlandırma ve ticaret yapılmayan filtreye düşer. $w_t = 2\kappa\sigma_*(x)$. Tek fark kaynaktır: GP, genişliği bir kalibrasyon seti yerine modelin kendisinden üretir, dolayısıyla geçmiş artıkların küresel bir niceliği yerine test noktasının eğitim verilerine göre bulunduğu yere göre değişir.

GPyTorch ile Uygulama

GPyTorch, ölçeklenebilir GP çıkarımına yönelik PyTorch tabanlı bir kitaplıktır. GP'leri saflığın ötesinde ölçeklendirmek için GPU hızlandırmayı, otomatik farklılaşmayı ve modern doğrusal cebir tekniklerini (eşlenik gradyanlar, Lanczos ayrıştırması) kullanır. $O(n^3)$ Sınır.

Dönüş Tahmini için Temel Tam 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 yukarıda tartışılan boyut başına uzunluk ölçeklerini mümkün kılan şeydir. Eğitimden sonra, model.covar_matern.base_kernel.lengthscale okunacak vektördür.

Eğitim Döngüsü

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

Belirsizlikle Tahmin

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

The fast_pred_var() bağlam yöneticisi, tahmine dayalı varyansları hesaplamak için LOVE (Lanczos Varyans Tahminleri) algoritmasını kullanır. $O(n)$ bunun yerine zaman $O(n^2)$.

Uçtan Uca Ticaret Hattı

Aşağıdaki özellik oluşturucuya ilişkin not: Her dönen istatistik kesinlikle geriye dönük olmalı ve girdi standardizasyonu yalnızca eğitim dilimine uygun olmalıdır. Bu ikinci nokta genel hijyen değildir; her sızıntı türünün ürettiği Sharpe enflasyonunu raporlayan, ileriye dönük önyargı taksonomisinde parçalara ayrılan ve ölçülen normalizasyon sızıntısı kanalıdır. Bir pratisyen hekim, girdilerini yapıya göre standartlaştırır, dolayısıyla en çok maruz kaldığı sızıntı budur.

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

Seyrek GP'lerle Daha Büyük Veri Kümelerine Ölçeklendirme

Eğitim penceresi birkaç bin noktayı aştığında kesin GP çıkarımı yavaşlar. Değişken seyrek GP'ye geçin:

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 tetikleme noktasıyla parti başına maliyet $O(128^2 \times \text{batch\_size})$ — parti başına yaklaşık 4 milyon işlem. Bu, tek bir GPU'da 100.000'den fazla gözlemin veri kümelerini kolayca yönetir.

Derin Çekirdek Öğrenimi: GP Sinir Ağlarıyla Buluşuyor

Girdi alanı yüksek boyutlu olduğunda veya özellikler ile getiriler arasındaki ilişki oldukça doğrusal olmadığında, düz bir çekirdek zorlanabilir. Derin çekirdek öğrenimi (DKL), GP çekirdeğini uygulamadan önce girdileri bir sinir ağından geçirir:

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

Neresi $g_\phi$ parametrelere sahip bir sinir ağıdır $\phi$ Ve $k_{\text{base}}$ standart bir çekirdektir (örneğin, Matern-3/2). Ağ, GP çekirdeğinin en etkili olduğu yerde bir özellik gösterimini öğrenir. Modelin tamamı (ağ parametreleri ve çekirdek hiperparametreleri) marjinal olasılığı maksimuma çıkararak uçtan uca eğitilir.

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, sinir ağlarının temsil öğrenimini pratisyen hekimlerin belirsizlik ölçümüyle birleştirir. GP katmanı, eğitim verilerinden uzaktaki tahminlerin yüksek belirsizliğe sahip olmasını sağlar; bu, standart sinir ağlarının sağlayamadığı bir şeydir. Ayrıca DKL'nin, marjinal olasılığın denetlemesi gereken esnekliği tam olarak yeniden sunduğuna dikkat edin: Occam faktörü çekirdeği cezalandırır, ancak önündeki ağda binlerce serbest parametre vardır ve böyle bir ceza yoktur.

Ludkovski ve Risk (2025), Kantitatif Finans için Gauss Süreç Modelleri, DKL'yi opsiyon fiyatlandırması ve portföy optimizasyonu da dahil olmak üzere daha geniş bir kantitatif finans bağlamında araştırıyor; bu sonuçlar onların sorunlarına ilişkindir ve kripto getiri tahmini hakkında kanıt değildir.

Teşhis ve Tuzaklar

Kalibrasyon

İyi kalibre edilmiş bir pratisyen hekim, ampirik kapsama uygun tahmin aralıklarına sahiptir. Kontrol, uygun tahmin'de kullanılanla aynıdır — bu aynı zamanda marjinal kapsamın neden koşullu kapsam olmadığı teorisini de kapsar; bu sınırlama GP aralıkları için de aynı derecede geçerlidir:

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}"
        )

Beklenen aşılma 1/2/3 sigma'da 0,317 / 0,046 / 0,003'tür. Önemli olan sayı, bunun kripto çubukları üzerinde gerçek bir ileri adım atıldığında ne yazdırdığıdır ve bu tablo henüz bu makalede yer almamaktadır. Önceki beklenti, GP'nin kendine aşırı güvendiğidir - kalın kuyruklu, durağan olmayan getirilere ilişkin Gauss olasılığının 3 sigma'da kötü bir şekilde gizlenmesi gerekir - ancak "olmalı" bir ölçüm değildir.

Kalan Tuzaklar

1. Giriş ölçeklendirme. Uzunluk ölçekleri giriş ölçeğine göredir, dolayısıyla bir özellik aralıklıdır $[0, 10000]$ ve biri aralıklı $[0, 1]$ anlamlı bir paylaşım yapamıyorum $\ell$; ARD, heterojen aralıkları kurtaran şeydir ve standardizasyon, ARD'nin başlatılmasını mantıklı kılan şeydir.

2. Marjinal olasılığın fazla uydurulması. Pek çok çekirdek hiperparametresi (özellikle kompozit veya spektral karışım çekirdekleri) ile, marjinal olasılık yine de gereğinden fazla sığabilir. Öncülleri kullanın: ortanca ikili mesafeye ortalanmış uzunluk ölçeklerinde log-normal bir öncelik, varyanslarda yarı-normal bir öncelik.

3. Kovaryans matrisi koşullandırması. $(K + \sigma_n^2 I)$ gürültü olduğunda sayısal olarak tekil hale gelebilir $\sigma_n^2$ çok küçük olduğunda veya eğitim noktaları neredeyse iki katına çıktığında. GPyTorch ekler $10^{-6}$ diyagonal titreşim; kötü koşullandırılmış finansal veriler genellikle daha fazlasına ihtiyaç duyar.

4. İleriye bakma önyargısı. Yukarıda ve ayrıntılı olarak ileriye bakma önyargısı sınıflandırmasında ele alınmıştır.

GP'ler ve Diğer Modeller Ne Zaman Kullanılmalı?

* XGBoost ve sinir ağı sütunları için, burada yeni bir iddia yerine yayınlanmış karşılaştırmalara başvurun: makine öğrenimi ile yayılma modellemesi, finansal tablo verileri (veri boyutu eşikleri, yorumlanabilirlik, rejim uyarlaması, gecikme) ve zamansal füzyon) için gradyan artırmaya karşı derin öğrenme tablosuna sahiptir transformatörler TFT'ye karşı LSTM'ye karşı vanilya Transformer'a sahiptir.

GP'leri şu durumlarda kullanın:

• Küçük ila orta ölçekli veri kümeleriniz var (eğitim penceresi başına ~10.000 gözlemin altında)
• Sinyal hakkında açık, incelenebilir bir yapısal hipotez istiyorsunuz (trend + mevsimsellik + gürültü)
• Belirsizlik, yalnızca küresel artık nicelik dilimine göre değil, eğitim verilerine olan mesafeye göre de değişmelidir.

Aşağıdaki durumlarda GP'leri kullanmayın:

• Milyonlarca gözlem üzerinden milisaniyenin altında çıkarımlara ihtiyacınız var
• Giriş boyutu ~50'yi aşıyor
• Sinyal, sabit çekirdeklerin temsil edemeyeceği karmaşık yüksek dereceli özellik etkileşimlerinde yaşar (DKL, Occam özelliği pahasına yardımcı olur)

Bu Makalenin Henüz Ölçmediği Şeyler

Yukarıdaki her şey model makinelerdir. Bunların hiçbiri bir pratisyen hekimin kriptodan para kazandığına dair kanıt değil ve bu blogun standardı, makalenin kendi rakamlarını taşımasıdır. Açık öğeler çalıştırılma sırasına göre:

1. ARD uzunluk ölçekleri gerçek BTCUSDT 1m çubukları üzerindedir. Bileşik çekirdeği takın, yazdırın $\ell_d$ özellik başına. Bu doğrudan "ARD yerleşik özellik seçimidir" iddiasını test eder ve yanlışlanabilir bir özellik alaka sıralaması üretir.
2. İleriye doğru yapılan bir çalışmanın kalibrasyon tablosu. Pratisyen hekimin kendine aşırı güvendiği durum da dahil olmak üzere, açıkça ifade edilen 1/2/3 sigma'da beklenen ve ampirik aşılma.
3. dürüst negatif ile aynı beş ana dalda ileriye dönük güven kapılı strateji, deneme sayımı için söndürüldü. Başarısız olursa, başka bir negatif sonuç olarak bu seriye girer.
4. Duvar saati $O(n^3)$ için eğri $n = 250 / 500 / 1000 / 2000 / 5000$, kesin ve SVGP, yani ölçeklenebilirlik bölümü bir iddia yerine bir grafiğe dayanır.

Sonuç

Ticaretteki Gauss süreçlerinin durumu "size hata çubukları verirler" değildir; uyumlu tahmin size daha az dağılım varsayımına sahip hata çubukları verir ve GP'nin sahip olmadığı bir kapsam garantisi verir. Durum şu ki, bir pratisyen hekim yapısal hipotezinizi bir çekirdek olarak yazmanızı sağlar, onu kendi karmaşıklığına göre fiyatlandıran bir hedefe göre ayarlar ve ardından ARD uzunluk ölçekleri aracılığıyla gerçekte hangi özelliklerinizi kullandığını size söyler. Bu alışılmadık derecede okunaklı bir model.

Maliyetler de aynı derecede somut: eğitim pencerenizi kapatan kübik ölçeklendirme, kayan pencerenin yalnızca kısmen onarıldığına dair durağanlık varsayımları, kalın kuyruklu getirilerin ihlal edileceğine dair Gauss olasılığı ve - derin çekirdek öğrenimine ulaştığınızda - ilk etapta marjinal olasılığı motive eden tam da Occam özelliğinin sessiz kaybı. Geriye kalanın ticarete açık olup olmadığı ampirik bir sorudur ve yukarıda sıralanan dört ölçüm bu soruyu yanıtlayacaktır.

Referanslar

• Rasmussen, C.E. ve Williams, C.K.I. (2006). Makine Öğrenimi için Gauss Süreçleri. MİT Basın.
• Wilson, A. ve Adams, R. (2013). Örüntü Keşfi ve Ekstrapolasyon için Gauss Süreç Çekirdekleri. ICML.
• Hensman, J., Fusi, N. ve Lawrence, N.D. (2013). Büyük Veri için Gauss Süreçleri. UAI.
• Gatheral, J., Jaisson, T. ve Rosenbaum, M. (2018). Volatilite kabadır. Nicel Finans, 18(6).
• Rizvi, S.A.A., Roberts, S.J., Osborne, M.A. ve Nyikosa, F. (2017). Gauss Süreç Zarfları ile Finansal Oynaklığın Tahmin Edilmesine Yeni Bir Yaklaşım. arXiv:1705.00891.
• Ludkovski, M. ve Risk, J. (2025). Kantitatif Finans için Gauss Süreç Modelleri. Springer.
• Gardner, J.R., Pleiss, G., Bindel, D., Weinberger, K.Q. ve Wilson, A.G. (2018). GPyTorch: GPU Hızlandırmalı Blackbox Matrix-Matrix Gauss Süreç Çıkarımı. NeurIPS.