Transformers ile bütün bir Numerai dönemini aynı anda işlemek.

Bana kodu vermen yeterli ️:

GPU -> Bir gönderim dosyası oluşturan tüm not defterlerini çalıştırın. 15 dakika içinde çalışır.

Numer.ai'nin turnuvalarında yeniyseniz, aşağıdaki gönderiler bu gönderi hakkında bilgi almak için yardımcı olabilir.

• https://docs.numer.ai/tournament/learn
• "Gezegendeki en zor turnuva" için kolay bir rehber
• Sinyaller hakkında konuşalım

Veriler (Eras) ​​⌗

Sağlanan veri seti ( v4.1: Sunshine ), "Era" (bir tamsayı) adı verilen gruplara bölünmüş, geçmiş on yılların karışık borsa verilerini içerir. Eras göreceli bir zamanlama duygusunu temsil eder, yani 1. dönem 2. dönemden önce olmuştur ve toplamda yaklaşık 1050 döneme kadar böyle devam eder. Eğitim ve doğrulama kümelerine ayrılırlar.

Dizi Olarak Dönem ⠿

Çoğu model, her satırı herhangi bir dönem bağlamı olmadan bir örnek olarak ele alır. Era Boosting gibi yaklaşımlar, mevcut topluluğun mücadele ettiği dönemlerde ek ağaçlar yetiştirir. Ancak, bu yine de tahmin için tüm döneme bakmıyor. Veri bilimcilerin birincil amacı, belirli bir dönemdeki örnekleri sıralamak olduğundan, yalnızca özelliklere değil, aynı zamanda bir dönemdeki tüm örneklere bakabilmek mantıklıdır. Bu, bir çağdaki tüm örneklere bakıp bundan bir şey çıkarsa, ne yapabileceğimizi merak etmemize yol açar! Olasılıklar, Era Kümelenmesi, Tek geçişte Sentetik dönem üretimi vb. Soru şu ki, her şeyi (hepsini) aynı anda görebildiğinden, bir grup hisse senedinin hareketleri hakkında bazı bilgiler sağlayabilir mi?

Bir süredir bu fikirler üzerinde çalışmaya çalışıyorum. LSTM ile ilk deneyler başarılı olmadı (belki o zamanlar onu düzgün bir şekilde uygulayamadım). Transformers ile ilk denemelerim, 5 benzersiz giriş değerinin {0, 1, 2, 3, 4} gömülmesini kullanarak her satırı bir dizi olarak ele aldı. Ancak, sadece Transpoze ederek tüm dönemi tek seferde işleyebilmelidir.

(Era)Transformer yardıma yetişiyor

Her satırı bir örnek olarak ele almak yerine, dönem sabit bir MAX_LENGTH'ye kadar doldurulur ve bu nedenle bir dizi olarak ele alınır. Seçilen özellikler, aşağıdaki çizimde gösterildiği gibi yastıklı konumlarda maske ile birlikte modele gömülü olarak beslenir.

def pad_sequence(inputs, padding_value=-1, max_len=None):
    if max_len is None:
        max_len = max([input.shape[0] for input in inputs])
    padded_inputs = []
    masks = []
    for input in inputs:
        pad_len = max_len - input.shape[0]
        padded_input = F.pad(input, (0, 0, 0, pad_len), value=padding_value)
        mask = torch.ones((input.shape[0], 1), dtype=torch.float)
        masks.append(
            torch.cat((mask, torch.zeros((pad_len, 1), dtype=torch.float)), dim=0)
        )
        padded_inputs.append(padded_input)
    return torch.stack(padded_inputs), torch.stack(masks)

def convert_to_torch(era, data):

    inputs = torch.from_numpy(
                data[feature_names].values.astype(np.int8))
    labels = torch.from_numpy(
                data[target_names].values.astype(np.float32))
    
    padded_inputs, masks_inputs = pad_sequence(
            [inputs], padding_value=PADDING_VALUE, max_len=MAX_LEN)
    padded_labels, masks_labels = pad_sequence(
            [labels], padding_value=PADDING_VALUE, max_len=MAX_LEN)

    return {
        era: (
            padded_inputs,
            padded_labels,
            masks_inputs
        )
    }

def get_era2data(df):
    res = Parallel(n_jobs=-1, prefer="threads")(
        delayed(convert_to_torch)(era, data)
        for era, data in tqdm(df.groupby("era_int")))
    era2data = {}
    for r in tqdm(res):
        era2data.update(r)
    return era2data


era2data_train = get_era2data(train)
era2data_validation = get_era2data(validation)
class TransformerEncoder(nn.Module):
    def __init__(
        self,
        input_dim,
        d_model,
        output_dim,
        num_heads,
        num_layers,
        dropout_prob=0.15,
        max_len=5000,
    ):
        super(TransformerEncoder, self).__init__()
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.num_heads = num_heads
        self.num_layers = num_layers
        self.dropout_prob = dropout_prob
        self.d_model = d_model

        self.positional_encoding = PositionalEncoding(d_model, max_len)
        self.attention = MultiHeadLinearAttention(d_model, num_heads)
        self.fc = nn.Sequential(
            nn.Linear(d_model, d_model),
        )
        self.layers = nn.ModuleList(
            [
                nn.Sequential(FeedForwardLayer(d_model=d_model))
                for _ in range(num_layers)
            ]
        )
        self.mapper = nn.Sequential(
            nn.Linear(input_dim, d_model), nn.Linear(d_model, d_model)
        )

    def forward(self, inputs, mask=None):
        x = self.mapper(inputs)
        pe = self.positional_encoding(x)
        x = x + pe # works without PE as well
        for layer in range(self.num_layers):
            attention_weights = self.attention(x, mask)
            x = x + attention_weights
            x = F.layer_norm(x, x.shape[1:])
            x = F.dropout(x, p=self.dropout_prob)

            op = self.layers[layer](x)
            x = x + op
            x = F.layer_norm(x, x.shape[1:])
            x = F.dropout(x, p=self.dropout_prob)

        outputs = self.fc(x)
        return outputs

Normal dikkat, dizüstü bilgisayar GPU'm için çok ağırdı, bu yüzden, matris çarpım yükünü önce D_MODEL ve ardından MAX_LEN olarak azaltacağı için Linear Dikkat gibi bir şey kullanmayı denedim . Sağlanan not defterindeki standart Colab çalışma zamanı, daha yüksek GPU belleğine sahip olduğundan, sağlanan küçük özellik alt kümesinde normal dikkat mekanizmasını kullanır. Dizüstü bilgisayarda, Çok kafalı dikkat bloğu için açılan yedek olarak her ikisi de mevcuttur. Sizin için hangisi işe yararsa onu kullanın.

Sonuçlar

Sağlanan Colab'deki deneyler, bellek sınırlamaları nedeniyle "küçük" özellik alt kümesini kullanır. Ancak, vanilya dikkat mekanizmasını kullanır. Aşağıda, MSE ve Pearson korelasyonunu optimize etmek için düşük öğrenme hızında 10 yineleme için ayarlanmış küçük özellik üzerinde eğitilmiş küçük bir model bulunmaktadır.

Kodlayıcı çıktısında ortogonal yerleştirmeleri zorlayacak bir kayıp işlevi, kümeleme için çok daha anlamlı olacaktır. Mevcut uygulama, daha çok erken bir deneydir ve mükemmel uygulama için daha doğru olacaktır. Yine de çalışıyor gibi görünüyor.

Eğitim Performansı

Doğrulama Performansı

Meta modele göre

Kümeleme

Sıradaki ne?

1. Colab not defterini çalıştırın (GPU->Tümünü çalıştır). Bir gönderim dosyası oluşturur
2. Özellik setini genişletin (küçük -> orta -> tam set)
3. Dikkat mekanizmalarıyla oynayın.
4. Daha iyi yerleştirmeler elde etmek için kayıp fonksiyonları
5. Sinyallerdeki veriler hakkında tam bir fikrimiz var; Orada çok daha geçerli olacak.
6. Difüzyon işlemini kullanarak sentetik Eras oluşturun
7. Kendi kendini yöneten eğitim

• https://github.com/lucidrains/linear-attention-transformer
• https://numer.ai/data/v4.1
• Yine Colab not defteri
• ChatGPT + Github Yardımcı Pilot