L'apprentissage automatique dans la négociation : théorie, modèles, pratique et algo-trading - page 2268

[Maxim Dmitrievsky]

mytarmailS:

Je ne peux pas le faire.

5k stagiaire

Test de 40k

Essayez d'appliquer mon critère à votre gmm, il devrait être plus facile de trouver des modèles fonctionnels.

J'utilise déjà R^2.

J'obtiens les mêmes tourbillons, mais en mieux).

[Rorschach]

Maxim Dmitrievsky:

tout est comme d'habitude, juste les marques avec la moyenne en tête. La disposition des lieux est complètement différente, ce qui est intéressant.

J'ai récemment publié un livre dans lequel une idée intéressante consistait à définir les poids du réseau selon la méthode classique, puis à les affiner avec l'entraînement. Je me demande s'il existe des moyens de combiner l'entraînement avec un professeur et le renforcement.

[Maxim Dmitrievsky]

Rorschach:

J'ai récemment publié un livre dans lequel une idée intéressante consistait à définir les poids du réseau selon la méthode classique, puis à les affiner avec l'entraînement. Je me demande s'il existe des moyens de combiner l'entraînement avec un professeur et le renforcement.

Ce sont tous des analogues de Mashka.

[Rorschach]

Maxim Dmitrievsky:

Ce sont tous des analogues sophistiqués de la maschka.

Les grilles ont l'avantage de la non-linéarité et du mode de sélection des paramètres, mais ce sont les mêmes filtres.

Il y a juste beaucoup de négativité à propos de l'apprentissage par renforcement. Les filets avec un enseignant donnent de meilleurs résultats en voiture, de même pour les jeux. Ils ont même inventé une grille à la fin d'un niveau pour s'entraîner et réorganiser le spawn plus proche du début. C'est aussi intéressant, l'expérience de la datasynth décide. Unity a créé un jeu spécifiquement pour ML et a mis en place un championnat. L'homme atteint en moyenne le niveau 20. Ils ont pris les 2 méthodes les plus récentes sur les grilles, avec leur aide ils ont atteint le niveau 4 en moyenne. Et les experts ont pu montrer des résultats à la hauteur d'un homme.

[Maxim Dmitrievsky]

Rorschach:

Les grilles ont l'avantage de la non-linéarité et du mode de sélection des paramètres, mais ce sont les mêmes filtres.

Il y a juste beaucoup de négativité à propos de l'apprentissage par renforcement. Dans les voitures, les filets avec un enseignant donnent de meilleurs résultats, de même que les jeux. Ils ont même inventé une grille à la fin d'un niveau pour s'entraîner et réorganiser le spawn plus proche du début. C'est aussi intéressant, l'expérience de la datasynth décide. Unity a créé un jeu spécifiquement pour ML et a mis en place un championnat. L'homme atteint en moyenne le niveau 20. Ils ont pris les 2 méthodes les plus récentes sur les grilles, avec leur aide ils ont atteint le niveau 4 en moyenne. Et les experts du championnat ont pu montrer des résultats à la hauteur d'une personne.

J'ai eu un engouement pour RL mais c'est fini maintenant... Les Transformers et les GANs sont à la mode maintenant.

[mytarmailS]

Maxim Dmitrievsky:

Il y a eu un engouement pour RL, mais c'est fini maintenant... les transformateurs et les GAN sont à la mode maintenant.

Les cerveaux sont à la mode ! Ils connaissent tous les algorithmes et savent comment appliquer un algorithme spécifique à une tâche spécifique, et non pas pour courir après les tendances.

Si vous avez besoin de gagner en GO, alors pourquoi s'embêter avec le GAN ? Si vous avez besoin de classer les iris, alors pourquoi s'embêter avec le RL ?

heh, chaque chose a sa place !

[Maxim Dmitrievsky]

mytarmailS:

Dans la tendance, il y a des cerveaux ! qui connaissent tous les algorithmes et savent comment appliquer un algorithme spécifique à une tâche spécifique, plutôt que de courir après les tendances.....

Si vous avez besoin de gagner en GO, pourquoi vous embêter avec le GAN ? Si vous avez besoin de classer les iris, pourquoi vous embêter avec le RL ?

Chaque chose a sa place !

Tu as un esprit étroit donc tu ne peux pas voir où et pourquoi.

[Rorschach]

Maxim Dmitrievsky:

Il y a eu un engouement pour le RL, c'est fini maintenant. Les Transformers et les GNs sont à la mode.

Les GAN sont intéressants à essayer pour générer des données artificielles.

Je pense que c'est une bonne idée de maîtriser ce cadre , tout ira alors beaucoup plus vite.

[Maxim Dmitrievsky]

Rorschach:

gan pour générer des données artificielles est intéressant à essayer.

Je ferais mieux de maîtriser ce cadre , alors tout ira beaucoup plus vite.

J'ai écrit mon gan, il n'y a rien de compliqué. Ce n'est pas récursif cependant, je vais devoir le refaire.

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

Voici un autre exemple

[Maxim Dmitrievsky]

Si vous ne voulez pas écrire quoi que ce soit, la solution toute prête