Multi-Task Learning for Simultaneous Price, Volume, and Volatility Prediction

Çok görevli öğrenme (MTL) genellikle bir iddiayla satılır: Bir kodlayıcıyı ilişkili hedefler arasında paylaşırsanız birincil görev daha iyi hale gelir. Ticarette ilişkili hedefler açıktır - getiriler, hacim ve gerçekleşen oynaklığın tümü aynı emir akışından çıkar - ve iddia neredeyse hiçbir zaman test edilmez. İlginç olan soru, görevlerin birbiriyle ilişkili olup olmadığı değildir. Önemli olan, paylaşılan degradelerin aynı olup olmadığı ve uyuşmadığı kıvrımlarda ne olduğudur.

Bu makale, çoğu MTL yazısının dipnot olarak ele aldığı iki şeyi merkeze koyuyor:

1. Kayıp dengeleme bir deneydir, ayrıntı değildir. Sabit ağırlıklar, Kendall belirsizlik ağırlıklandırması ve GradNorm üç farklı modeldir. Üçünü de aynı katlarda çalıştırın ve öğrenilen ağırlıkları her biri için birincil görev metriği ile birlikte rapor edin.
2. Negatif aktarım, metriği görmeden önce ölçülebilir. Paylaşılan kodlayıcıdaki görev gradyanları arasındaki kosinüs benzerliği, eğitim sırasında, yardımcı görevlerin temsili birincil görevin gitmek istediği yere çekip çekmediğini size söyler. Kosinüsleri imzalayın, ardından işaretin bu kattaki sonucu tahmin edip etmediğini kontrol edin.

Devam eden her şey (volatilite süreci, eğitim döngüsü, sızıntı kontrolleri, doğrulama protokolü) zaten bu blogun başka bir yerinde ele alınıyor ve yeniden türetilmek yerine bağlantılı.

Kurulum

Verilen giriş özellikleri $\mathbf{x} \in \mathbb{R}^d$ (OHLCV, teknik göstergeler, sipariş akışı), üç hedef:

• Görev 1 (birincil): sonraki döneme dönüş $y^{(1)} = r_{t+1}$
• Görev 2 (yardımcı): sonraki dönem günlük hacmi $y^{(2)} = \log V_{t+1}$
• Görev 3 (yardımcı): sonraki dönemde gerçekleşen oynaklık $y^{(3)} = \sigma_{t+1}$

Çok görevli bir model, üçünü de aynı anda üretir. $\hat{\mathbf{y}} = f_\theta(\mathbf{x})$ve çoklu görev riski, görev başına risklerin ağırlıklı toplamıdır:

$\mathcal{R}_{\text{MTL}}(\theta) = \sum_{k=1}^{K} w_k \cdot \mathbb{E}\bigl[\ell^{(k)}(f_\theta^{(k)}(\mathbf{x}), y^{(k)})\bigr]$

Makalenin tamamı bununla ilgili $w_k$ ve görev başına gradyanların birbirlerine ne yaptığı hakkında.

Bir paragrafta ortak eğitim neden yardımcı olabilir? Yardımcı görevler, ortak temsili birden fazla piyasa olgusunu açıklamak için kısıtlar; bu, aynı anda bir kapasite kontrolü ve tümevarımsal bir önyargıdır; ve "beklenen getiri" gözlemlenmezken hacim ve volatilite doğrudan gözlemlendiğinden, yardımcı kafalar birincil kafadan daha temiz gradyan sinyali sağlar. Çok sayıda çıktı yayan bir modelin durumu, yorumlanabilirlik mekanizması eklenmiş olarak, çoklu ufuk tahminleri için geçici füzyon transformatörleri belgesinde uzun uzadıya tartışılıyor; bu, çok ufuklu nicelikler için aynı paylaşılan kodlayıcı-çok kafalı argümanı ortaya koyuyor.

Mimarlık, kısaca

Sabit parametre paylaşımı: paylaşılan bir kodlayıcı $g_\phi$ beslemeler $K$ göreve özel kafalar $h_{\psi_k}$, Bu yüzden $\hat{y}^{(k)} = h_{\psi_k}(g_\phi(\mathbf{x}))$. Bu, burada ölçülen sürümdür, çünkü bu, degrade çakışmasının olduğu sürümdür. $\phi$ iyi tanımlanmıştır.

Yumuşak parametre paylaşımı, bağlantı cezasıyla birlikte her göreve kendi kodlayıcısını verir $\lambda \sum_{k \neq j} \|\phi_k - \phi_j\|^2$ — daha fazla parametre, daha fazla esneklik ve çatışmayı ölçecek tek bir paylaşılan parametre vektörünün olmaması. Çapraz dikiş ağları ikisinin arasında yer alır ve öğrenilen bir matris aracılığıyla göreve özel özellikleri birleştirir $\alpha_{kj}$ her seviyede. Sabit paylaşım çatışma gösteriyorsa her ikisi de denemeye değerdir ve her ikisi de aşağıdaki ölçümün kapsamı dışındadır.

Önemli Olan Deney: Üç Kayıp Dengeleme Planı

Saf kayıp $\mathcal{L} = \sum_k w_k \mathcal{L}^{(k)}$ ölçeğe duyarlıdır. Geri dönüş kaybı yaşanırsa $0.01$ ve civarında hacim kaybı $1.0$, hacim degradenin sahibidir ve geri dönüş kafası açlıktan ölür. Üç yanıt:

Sabit ağırlıklar. Ayarla $w_k = 1$ her hedefi standartlaştırdıktan sonra. Dürüst temel; eğer kazanırsa, uyarlanabilir planlar törensel olacaktır.

Belirsizlik ağırlıklandırması (Kendall ve diğerleri, 2018). Homoskedastik gürültü ölçeğini öğrenin $\sigma_k$ görev başına:

$\mathcal{L}_{\text{MTL}} = \sum_{k=1}^{K} \frac{1}{2\sigma_k^2} \mathcal{L}^{(k)} + \log \sigma_k$

Belirsizliği yüksek görevlerin ağırlığı otomatik olarak azaltılır; the $\log \sigma_k$ terim önemsiz şeyleri engeller $\sigma_k \to \infty$ çözüm. Bunu not et $\sigma_k$ bir tahmin aralığı değil, eğitim süresi kaybını ağırlıklandırma aracıdır. Belirsizlik için aslında bir pozisyonu boyutlandırabilirsiniz, bkz. konformal tahmin.

GradNorm (Chen ve diğerleri, 2018). Kayıp ölçekleri yerine denge gradyanı büyüklükler. Her adım: hesaplama $G_k = \|\nabla_\phi w_k \mathcal{L}^{(k)}\|_2$ ve ortalama $\bar{G}$, bağıl eğitim oranını hesaplayın $\tilde{r}_k = \frac{\mathcal{L}^{(k)}(t)/\mathcal{L}^{(k)}(0)}{\bar{r}}$ve güncelleme $w_k \leftarrow w_k - \eta_w \nabla_{w_k} \sum_k |G_k - \bar{G} \cdot \tilde{r}_k^\alpha|$. Daha sonra tüm görevler, kayıp ölçeğine bakılmaksızın karşılaştırılabilir oranlarda eğitilir.

MTL'ye özgü kod, başlıklar, ileriye dönen liste ve kayıp toplamadır. Doğrusal/BatchNorm/ReLU/Bırakma yığını, Adam/kosinüs/klip ortak metni ve dönem döngüsü, DeepLOB'da gösterilen standart modeldir ve burada belirtilmemiştir.

import torch
import torch.nn as nn


class MultiTaskTradingModel(nn.Module):
    """Hard parameter sharing: one encoder, K heads."""

    def __init__(self, encoder: nn.Module, repr_dim: int, n_tasks: int = 3):
        super().__init__()
        self.shared_encoder = encoder          # any MLP/CNN/GRU trunk
        self.task_heads = nn.ModuleList(
            nn.Linear(repr_dim, 1) for _ in range(n_tasks)
        )

    def forward(self, x):
        h = self.shared_encoder(x)
        return [head(h).squeeze(-1) for head in self.task_heads]

    def shared_repr(self, x):
        return self.shared_encoder(x)


class UncertaintyWeightedLoss(nn.Module):
    """Kendall et al. (2018) homoscedastic weighting."""

    def __init__(self, n_tasks: int = 3):
        super().__init__()
        self.log_vars = nn.Parameter(torch.zeros(n_tasks))  # log(sigma^2)

    def forward(self, losses: list) -> torch.Tensor:
        return sum(
            torch.exp(-self.log_vars[i]) * loss + self.log_vars[i]
            for i, loss in enumerate(losses)
        )

    def get_weights(self) -> list:
        with torch.no_grad():
            return [torch.exp(-lv).item() for lv in self.log_vars]

UncertaintyWeightedLoss parametreleri vardır, bu nedenle modelin yanında optimize ediciye girmesi gerekir: optim.Adam(list(model.parameters()) + list(uw.parameters()), ...). Bunu unutmak, "belirsizlik ağırlıklandırmasını çalıştırmanın" ve bunun yerine sessizce sabit ağırlıkları çalıştırmanın en yaygın yoludur.

Ne rapor edilmeli

Her şema için, her katlamada: öğrenilen son görev ağırlıkları, birincil görev metriği ve - ağırlıklandırma şeması bir model seçimi olduğundan - bir tanesini seçmeden önce kaç şemanın karşılaştırıldığı.

Üç şema çarpı birkaç kat zaten küçük bir model arayışıdır. Burada rapor edilen herhangi bir iyileştirmenin, bir anlam ifade etmesinden önce deflated Sharpe ve çoklu test bölümünde açıklanan çoklu test düzeltmesinden sonra hayatta kalması gerekir.

Negatif Aktarım: Degradeleri İmzalayın

Bu, tutmaya değer kısımdır. Negatif transfer, yardımcı görevlerin birincil görevi daha da kötüleştirdiği zamandır ve doğrudan bir tanıya sahiptir: paylaşılan parametre alanındaki görev dereceleri arasındaki açı.

$\cos\bigl(\nabla_\phi \mathcal{L}^{(k)}, \nabla_\phi \mathcal{L}^{(j)}\bigr) < 0 \implies \text{conflicting tasks}$

Yalnızca paylaşılan kodlayıcıda ölçülmüştür; kafalar yapı gereği göreve özeldir ve her zaman önemsiz bir şekilde "anlaşır".

import torch.nn.functional as F


def shared_grad(model, x, y, task_idx, criterion=nn.MSELoss()):
    """Gradient of task `task_idx` w.r.t. the shared encoder, flattened."""
    model.zero_grad(set_to_none=True)
    loss = criterion(model(x)[task_idx], y)
    loss.backward()
    return torch.cat([
        p.grad.detach().flatten()
        for p in model.shared_encoder.parameters()
        if p.grad is not None
    ])


def task_conflict(model, x, y_by_task, task_names):
    """Pairwise cosine similarity between per-task shared-encoder gradients."""
    grads = {
        name: shared_grad(model, x, y_by_task[name], i)
        for i, name in enumerate(task_names)
    }
    return {
        (a, b): F.cosine_similarity(
            grads[a].unsqueeze(0), grads[b].unsqueeze(0)
        ).item()
        for i, a in enumerate(task_names)
        for b in task_names[i + 1:]
    }

Bunu antrenmanın sonunda değil, antrenman sırasında sabit bir tempoda uzun bir süre boyunca yapın. Kodlayıcı uzmanlaştıkça bir çift aynı hizada başlayabilir ve farklılaşabilir; tek bir eğitim sonu numarası bunu gizler.

Aranacak ve her iki durumda da yayınlanacak bulgu:

Hacim ve oynaklık gradyanları birbiriyle uyumluyken her ikisi de dönüş gradyanı ile çelişiyorsa, doğru sonuç, iki yardımcı görevin, dönüş görevinin ait olmadığı tutarlı bir blok oluşturduğudur ve düzeltme, daha fazla kapasite değil, görev gruplamasıdır. Çatışma gerçek olduğunda standart çareler, her çelişkili eğimi diğerinin normal düzlemine yansıtan PCGrad'dır (Yu ve diğerleri, 2020); Hiçbir göreve zarar vermeyen bir iniş yönü arayan CAGrad (Liu ve diğerleri, 2021); veya yardımcı görevi tamamen bırakmak.

Neyin kasıtlı olarak eksik olduğuna dikkat edin: paylaşılan temsilin hedef değere göre renklendirilmiş bir t-SNE grafiği. Dekoratiftir - yukarıdaki kosinüs sayıları, yerleştirmenin işaret edeceği her şeyi belirtir ve bunu sayı olarak söylerler.

Doğrulama Protokolü

Yukarıdaki ölçümün özensiz bir protokol altında hiçbir değeri yoktur ve MTL, bir yerine sızdırılacak üç hedef olduğundan olağan tuzakları daha da kötüleştirir.

Gerçek veriler, simülatör değil. Hedefler gerçek OHLCV/ticaret verilerinden gelmelidir. Sabit kodlanmış bir GARCH oyuncağı, yapısal olarak getirilerle ilişkili volatilite üretir; bu da tam olarak test edilen şeydir; deney, kendi jeneratörünü ölçecektir. Uygun bir volatilite süreci istiyorsanız, Kripto için GARCH volatilite tahmini, gerçek BTC/ETH üzerinde maksimum olasılıkla GARCH(1,1)'e uyar ve standartlaştırılmış kalıntıları doğrular ve asimetrik GARCH ve kaldıraç etkisi neden bir Gaussian'ın açıklandığını kapsar simetrik tepki simülatörü ilk etapta kripto volatilitesini yanlış ifade ediyor. Sentetik veriler yalnızca kontrollü temel gerçeği (kurtarmaya çalıştığınız bilinen, yazar tarafından belirlenen bir görev korelasyonu) sağladığında savunulabilir; bu, buradakinden farklı bir deneydir.

Ölçekleyiciler yalnızca trene sığar. Özellik ölçekleyiciyi ve üç hedef ölçekleyicinin tümünü her eğitim katına yerleştirin ve doğrulama için uygulayın; küresel fit_transform sızıntı test seti anlarını eğitime ayırmadan önce. Bu kesin başarısızlık ileriye dönük önyargı sınıflandırmasında içinde kataloglanmıştır.

Temizlenmiş, ambargolu ileri yürüme katlamaları. 80/20'lik bir kronolojik bölünme, MTL iyileştirmesini katlama etkisinden ayırt edemez — bu, üç bölmenin üç sonuç ürettiğini gösteren ileriye doğru ilerleme optimizasyonunun tüm argümanıdır. Genişleyen pencereyi yeniden kullanma purged_walk_forward makine öğrenimi ile yayılmış modelleme'den oluşturucu: horizon her bir sınırın her iki tarafındaki sıralar; bu burada önemlidir çünkü örtüşen gerçekleşen volatilite pencereleri, dönüş hedefi olmasa bile sınırın ötesine sızar.

Klasik bir temel. Üç tek görevli ağı yenen bir MTL ağı, hedef başına eğimi artıran veya tepe modelinin dördünü de yendiği takdirde hiçbir şey kanıtlamamıştır. LightGBM veya çıkıntılı hedef başına bir modeli aynı kıvrımlara ve aynı özelliklere yerleştirin ve aynı tabloda raporlayın.

MTL'yi Burada Ne Değerlendirebilir?

MTL'nin kazanması gereken koşullar, bir kontrol listesi yerine yukarıdaki kıvrımları kontrol etmek için hipotezler olarak belirtilmiştir:

• Yardımcı etiketler ana etikete göre daha temizdir. Hacim doğrudan gözlemlenir; "beklenen getiri" değildir. Geri dönüş başlığı çoğunlukla uygun gürültüye sahipse, yardımcı başlıklardan gelen gradyan sinyali, hedefin iyi konumlandırılmış tek kısmıdır.
• Eğitim verileri kodlayıcı kapasitesine göre sınırlıdır, bu nedenle yardımcı kısıtlama yalnızca parametreler için rekabet etmek yerine gerçek düzenleme işini yapar.
• Çıkarım gecikmesi önemlidir ve bir ileri pas üçü yener.

Ve buna karşı olan durum da eşit derecede test edilebilir: eğer ölçülen cos_sim(return, ·) değerler sürekli olarak negatiftir, paylaşılan kodlayıcı birincil görevden uzaklaştırılmaktadır ve yardımcı kafalar düzenleyici değil, vergidir.

Sonuç

Getiriler, hacim ve oynaklık aynı mikro yapıdan gelir, dolayısıyla paylaşılan bir temsil makul bir önceliktir ancak öncelik bir sonuç değildir. Bu kurulumun gerçekte oluşturabileceği iki şey, verilerin tercih ettiği kayıp dengeleme şemasıdır (sadece kazananın adı değil, öğrenilen ağırlıkların raporlanmasıyla) ve paylaşılan kodlayıcıdaki görev gradyanlarının, hedeflerin ilişkili olduğu gerçeğinden yola çıkılarak varsayılmak yerine eğitim boyunca ölçülen, uyumlu olup olmadığıdır.

Temizlenen ileriye doğru kıvrımlar, MTL ağının hedef başına gradyan artırma modelini geçemediğini gösteriyorsa, bulgu budur ve bu şekilde yayınlanır - şablon dürüst negatiftir. Negatif transferde negatif sonuç yine negatif transferde sonuçtur.