L'apprendimento automatico nel trading: teoria, modelli, pratica e algo-trading - pagina 2268

[Maxim Dmitrievsky]

mytarmailS:

Non posso farlo ((

5k tirocinante

40k test

Prova ad applicare il mio criterio al tuo gmm, dovrebbe essere meglio trovare modelli funzionanti

Sto già usando R^2.

Ottengo gli stessi vortici solo meglio)

[Rorschach]

Maxim Dmitrievsky:

tutto è lo stesso come al solito, solo i segni con la media in mente. C'è un layout completamente diverso lì, il che è interessante

Ho recentemente pubblicato un libro in cui un'idea interessante era quella di impostare i pesi della rete secondo il metodo classico, e poi metterla a punto con l'allenamento. Mi chiedo se ci sono modi per combinare l'allenamento con un insegnante e con il rinforzo

[Maxim Dmitrievsky]

Rorschach:

Ho recentemente pubblicato un libro in cui un'idea interessante era quella di impostare i pesi della rete secondo il metodo classico e poi mettere a punto con l'allenamento. Mi chiedo se ci sono modi di combinare l'allenamento con un insegnante e con il rinforzo

questi sono tutti analoghi truccati di mashka

[Rorschach]

Maxim Dmitrievsky:

Questi sono tutti analoghi sofisticati della maschka.

Le griglie hanno il vantaggio della non linearità e del modo di selezionare i parametri, ma sono gli stessi filtri.

C'è solo un sacco di negatività sull'apprendimento per rinforzo. Le reti con un insegnante mostrano risultati migliori in auto, lo stesso nei giochi. Hanno persino inventato una griglia dalla fine di un livello per allenare e riorganizzare lo spawn più vicino all'inizio. È anche interessante, l'esperienza del datasynth decide. Unity ha fatto un gioco specifico per ML e ha organizzato un campionato. L'uomo in media arriva al livello 20. Hanno preso i 2 nuovi metodi su griglie, con il loro aiuto hanno raggiunto il livello 4 in media. E gli esperti sono stati in grado di mostrare risultati a livello di un uomo.

[Maxim Dmitrievsky]

Rorschach:

Le griglie hanno il vantaggio della non linearità e del modo di selezionare i parametri, ma sono gli stessi filtri.

C'è solo un sacco di negatività sull'apprendimento per rinforzo. Nelle macchine, le reti con un insegnante mostrano risultati migliori, e lo stesso vale per i giochi. Hanno persino inventato una griglia dalla fine di un livello per allenare e riorganizzare lo spawn più vicino all'inizio. È anche interessante, l'esperienza del datasynth decide. Unity ha fatto un gioco specifico per ML e ha organizzato un campionato. L'uomo in media arriva al livello 20. Hanno preso i 2 nuovi metodi su griglie, con il loro aiuto hanno raggiunto il livello 4 in media. E gli esperti del campionato sono stati in grado di mostrare risultati a livello di una persona.

Ho avuto un hype RL ma ora non c'è più... Transformers e GAN sono di tendenza ora.

[mytarmailS]

Maxim Dmitrievsky:

C'è stato un hype RL, ma ora è finito... i transformers e i GAN sono di tendenza ora.

I cervelli fanno tendenza! Conoscono tutti gli algoritmi e sanno come applicare un algoritmo specifico a un compito specifico, e non inseguire le tendenze.

Se hai bisogno di vincere in GO, allora perché preoccuparsi del GAN? Se hai bisogno di classificare gli Iris, allora perché preoccuparsi della RL?

heh, ogni cosa ha il suo posto!

[Maxim Dmitrievsky]

mytarmailS:

Nella tendenza c'è il cervello! che conosce tutti gli algoritmi e sa come applicare un algoritmo specifico a un compito specifico, piuttosto che inseguire le tendenze....

Se hai bisogno di vincere in GO, perché preoccuparsi del GAN? Se hai bisogno di classificare gli Iris, perché preoccuparsi della RL?

ogni cosa ha il suo posto!

Hai una mente piccola e non riesci a vedere dove e per cosa.

[Rorschach]

Maxim Dmitrievsky:

c'è stato un hype rl, ora è finito. transformers e gaNs sono di tendenza

Le GAN sono interessanti da provare per generare dati artificiali

Penso che sia una buona idea padroneggiare questa struttura , poi tutto andrà molto più veloce.

[Maxim Dmitrievsky]

Rorschach:

gan per la generazione di dati artificiali è interessante da provare

È meglio che io padroneggi questa struttura , allora tutto andrà molto più veloce.

Ho scritto il mio gan, non c'è niente di complicato. Non è ricorsivo però, dovrò rifarlo.

Esempio su Torcha.

декларация

#  creating cGAN
class Discriminator(nn.Module):
    def __init__(self, input_vector):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(input_vector, 500),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(500, 250),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(250, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.model(x)


class Generator(nn.Module):
    def __init__(self, input_vector):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(input_vector, 250),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(250, 500),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(500, input_vector)
        )

    def forward(self, x):
        return self.model(x)

обучение

tens = torch.FloatTensor(pr[pr.columns[1:]].values)
train_iterator = torch.utils.data.DataLoader(
    tens, batch_size=BATCH_SIZE, shuffle=True,)

discriminator = Discriminator(INPUT_VECTOR+1)
generator = Generator(INPUT_VECTOR+1)
optimizer_discriminator = torch.optim.Adam(discriminator.parameters(), lr=lr)
optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr)

for epoch in range(NUM_EPOCHS):
    for n, real_samples in enumerate(train_iterator):
        if real_samples.shape[0] != BATCH_SIZE:
            continue
        #  Data for training the discriminator
        real_samples_labels = torch.ones((BATCH_SIZE, 1))
        latent_space_samples = torch.randn((BATCH_SIZE, INPUT_VECTOR+1))
        generated_samples = generator(latent_space_samples)
        generated_samples_labels = torch.zeros((BATCH_SIZE, 1))
        all_samples = torch.cat((real_samples, generated_samples))
        all_samples_labels = torch.cat(
            (real_samples_labels, generated_samples_labels)
        )

        #  Training the discriminator
        discriminator.zero_grad()
        output_discriminator = discriminator(all_samples)
        loss_discriminator = loss_function(
            output_discriminator, all_samples_labels)
        loss_discriminator.backward()
        optimizer_discriminator.step()

        #  Data for training the generator
        latent_space_samples = torch.randn((BATCH_SIZE, INPUT_VECTOR+1))

        #  Training the generator
        generator.zero_grad()
        generated_samples = generator(latent_space_samples)
        output_discriminator_generated = discriminator(generated_samples)
        loss_generator = loss_function(
            output_discriminator_generated, real_samples_labels
        )
        loss_generator.backward()
        optimizer_generator.step()

        #  Show loss
        if epoch % 10 == 0 and n == BATCH_SIZE - 1:
            print(f"Epoch: {epoch} Loss D.: {loss_discriminator}")
            print(f"Epoch: {epoch} Loss G.: {loss_generator}")

Ecco un altro esempio

[Maxim Dmitrievsky]

Se non volete scrivere nulla, i ready-made