Memproses seluruh era Numerai sekaligus dengan Transformers.

Beri saya kode ️:

GPU -> Jalankan semua notebook yang menghasilkan file pengiriman. Berjalan dalam waktu 15 menit.

Jika Anda baru mengenal turnamen Numer.ai, postingan berikut mungkin berguna untuk mendapatkan konteks tentang postingan ini.

• https://docs.numer.ai/tournament/learn
• Panduan mudah untuk "Turnamen tersulit di planet ini"
• Mari kita bicara tentang Sinyal

Data (Eras) ​​⌗

Kumpulan data yang disediakan ( v4.1: Sunshine ) berisi data pasar saham yang disamarkan selama beberapa dekade terakhir yang dibagi ke dalam grup yang disebut "Era" (angka bilangan bulat). Era mewakili pengertian waktu yang relatif, artinya era 1 terjadi sebelum era 2 dan seterusnya hingga total sekitar 1050 era. Mereka dibagi menjadi set pelatihan dan validasi.

Era sebagai Urutan ⠿

Sebagian besar model memperlakukan setiap baris sebagai sampel tanpa konteks zaman. Pendekatan seperti Era Boosting melatih pohon tambahan pada era di mana ansambel saat ini sedang berjuang. Namun, ini masih belum melihat seluruh era untuk prediksi. Karena tujuan utama para ilmuwan data adalah untuk memeringkat sampel pada era tertentu, masuk akal untuk dapat melihat tidak hanya fitur tetapi juga semua sampel pada suatu era. Ini membuat kami bertanya-tanya apa yang bisa kami lakukan jika kami dapat melihat semua sampel di suatu era dan menyimpulkan sesuatu dari itu! Kemungkinannya adalah Era Clustering, Generasi era sintetis dalam satu lintasan, dll. Pertanyaannya adalah, dapatkah ini memberikan wawasan tentang pergerakan sekelompok stok karena dapat melihat semuanya (semua) sekaligus?

Saya telah mencoba mengerjakan ide-ide ini untuk sementara waktu sekarang. Eksperimen awal dengan LSTM tidak berhasil (mungkin saya tidak dapat mengimplementasikannya dengan benar saat itu). Uji coba awal saya dengan Transformers memperlakukan setiap baris sebagai urutan dengan menggunakan penyematan 5 nilai input unik {0, 1, 2, 3, 4}. Namun, seharusnya dapat memproses seluruh era sekaligus, cukup dengan Transposing.

Transformator (Era) untuk menyelamatkan

Alih-alih memperlakukan setiap baris sebagai sampel, era diisi ke MAX_LENGTH tetap dan dengan demikian diperlakukan sebagai urutan. Fitur yang dipilih diumpankan sebagai penyematan ke model bersama dengan mask di lokasi berlapis seperti yang ditunjukkan pada ilustrasi di bawah.

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

Perhatian vanilla terlalu berat untuk GPU laptop saya, jadi saya mencoba menggunakan sesuatu seperti Linear Attention karena akan mengurangi beban perkalian matriks menjadi D_MODEL pertama dan kemudian MAX_LEN . Runtime Colab standar di notebook yang disediakan menggunakan mekanisme perhatian vanilla pada sebagian kecil fitur yang disediakan karena memiliki memori GPU yang lebih tinggi. Notebook ini memiliki keduanya sebagai pengganti drop-in untuk blok perhatian Multi-head. Gunakan mana yang cocok untuk Anda.

Hasil

Eksperimen di Colab yang disediakan menggunakan subset fitur "kecil" karena keterbatasan memori. Namun, ia menggunakan mekanisme perhatian vanilla. Di bawah ini adalah model kecil yang dilatih pada set fitur kecil untuk 10 iterasi pada kecepatan pembelajaran rendah untuk mengoptimalkan korelasi MSE dan Pearson.

Fungsi kerugian yang akan menerapkan penyematan ortogonal dalam output pembuat enkode akan lebih masuk akal untuk pengelompokan. Implementasi saat ini lebih merupakan eksperimen awal dan akan mendapatkan implementasi yang lebih akurat hingga sempurna. Tampaknya berhasil.

Kinerja Pelatihan

Kinerja Validasi

Relatif terhadap meta-model

Kekelompokan

Apa berikutnya?

1. Jalankan notebook Colab (GPU->Jalankan semua). Menghasilkan file pengiriman
2. Perluas set fitur (kecil -> sedang -> set lengkap)
3. Bermain dengan mekanisme Perhatian.
4. Fungsi kerugian untuk mendapatkan penyematan yang lebih baik
5. Kami memiliki gagasan lengkap tentang data di Signals; Itu akan jauh lebih bisa diterapkan di sana.
6. Hasilkan Era sintetis menggunakan proses Difusi
7. Pelatihan yang diawasi sendiri

• https://github.com/lucidrains/linear-attention-transformer
• https://numer.ai/data/v4.1
• Sekali lagi buku catatan Colab
• ChatGPT + Kopilot Github