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

[mytarmailS]

Maxim Dmitrievsky:

transposer la série dans un autre espace (distribution ?)

Oui, dans un autre espace, je ne sais pas pour la distribution...

pourquoi des étiquettes de classe ? pourquoi des codeurs ?

[Maxim Dmitrievsky]

mytarmailS:

Oui, dans un autre espace, je ne sais pas pour la distribution...

pourquoi des étiquettes de classe ? pourquoi des codeurs ?

vous avez besoin de bons échantillons de vente et d'achat, c'est pourquoi les étiquettes

c'est la distribution des points dans cet espace, on choisit généralement la normale multivariée.

ça ne marchera probablement pas, mais c'est amusant.

que faites-vous si l'année prochaine le modèle change ? rien, vous ne pouvez pas le sortir de l'année en cours

Il faut prendre l'ensemble de l'historique, le décomposer en clusters, égaliser le nombre d'échantillons dans chaque cluster, puis générer des exemples à partir de ceux-ci et les entraîner. Ce sera +- constant, en théorie.

[mytarmailS]

Maxim Dmitrievsky:

vous avez besoin de bons exemples de vente et d'achat, de sorte que les notes

sont la distribution des points dans cet espace, généralement ...............

Eh bien oui, je suis d'accord que l'idée spécifique est si-so....

========================

Quel est votre robot sur les distributions ?

[Maxim Dmitrievsky]

mytarmailS:

Eh bien oui, je suis d'accord que l'idée spécifique est si-so....

========================

Quel est votre robot sur les distributions ?

c'est une idée cool, sur des données normales, pas aléatoires.

Cela ne fonctionne que sur les euros, pas tellement sur les autres.

J'utilise coder au lieu de gmm, je ne l'ai pas encore fait.

[34767361]

Kak prikrepiti instrument BTC/USD ?

[Maxim Dmitrievsky]

coder au lieu de gmm. Formation 2 mois, test 5 ans.

C'est un peu plus difficile de saisir l'architecture. La couche unique ne fonctionnait pas du tout, j'ai ajouté une 2ème couche, ça s'est amélioré.

des couches normales de feedforward.

[mytarmailS]

Maxim Dmitrievsky:

coder au lieu de gmm. Formation 2 mois, test 5 ans.

C'est un peu plus difficile de saisir l'architecture. La couche unique ne fonctionnait pas du tout, j'ai ajouté une 2ème couche, ça s'est amélioré.

Les couches habituelles de feedforward.

J'ai l'impression que le graphique est plus lisse avec gmm...

Pourquoi y a-t-il un neurone ? Pouvez-vous l'expliquer par un schéma fonctionnel ?

une seule couche ne peut résoudre que des problèmes linéaires

[Maxim Dmitrievsky]

mytarmailS:

Il me semble que le graphique gmm est plus lisse ...

Pourquoi y a-t-il un neurone ? Pouvez-vous expliquer le schéma fonctionnel ?

Une couche ne peut résoudre que des problèmes linéaires

Je m'attendais à plus de leur part

l'encodeur est une neuronique

vous ne comprendrez rien de toute façon, mais en voici la structure

class Encoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, latent_dim, n_classes):
        super().__init__()

        self.linear = nn.Linear(input_dim + n_classes, hidden_dim)
        self.mu = nn.Linear(hidden_dim, latent_dim)
        self.var = nn.Linear(hidden_dim, latent_dim)

    def forward(self, x):
        #  x is of shape [batch_size, input_dim + n_classes]

        hidden = torch.sigmoid(self.linear(x))
        #  hidden is of shape [batch_size, hidden_dim]

        #  latent parameters
        mean = self.mu(hidden)
        #  mean is of shape [batch_size, latent_dim]
        log_var = self.var(hidden)
        #  log_var is of shape [batch_size, latent_dim]

        return mean, log_var


class Decoder(nn.Module):
    def __init__(self, latent_dim, hidden_dim, output_dim, n_classes):
        super().__init__()

        self.latent_to_hidden = nn.Linear(latent_dim + n_classes, hidden_dim)
        self.hidden_to_out = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        #  x is of shape [batch_size, latent_dim + num_classes]
        x = torch.sigmoid(self.latent_to_hidden(x))
        #  x is of shape [batch_size, hidden_dim]
        generated_x = torch.sigmoid(self.hidden_to_out(x))
        #  x is of shape [batch_size, output_dim]

        return generated_x


class CVAE(nn.Module):
    def __init__(self, input_dim, hidden_dim, latent_dim, n_classes):
        super().__init__()

        self.encoder = Encoder(input_dim, hidden_dim, latent_dim, 1)
        self.decoder = Decoder(latent_dim, hidden_dim, input_dim, 1)

    def forward(self, x, y):

        x = torch.cat((x, y), dim=1)

        #  encode
        z_mu, z_var = self.encoder(x)

        #  sample from the distribution having latent parameters z_mu, z_var
        #  reparameterize
        std = torch.exp(z_var / 2)
        eps = torch.randn_like(std)
        x_sample = eps.mul(std).add_(z_mu)

        z = torch.cat((x_sample, y), dim=1)

        #  decode
        generated_x = self.decoder(z)

        return generated_x, z_mu, z_var

[mytarmailS]

Maxim Dmitrievsky:

le codeur est un neurone.

Sérieusement ? ))))) Tu te moques de moi ou quoi ? ))

Maxim Dmitrievsky:

tu ne comprendrais pas.

C'est pour ça que je vous le dis, dites-moi simplement ce que vous attendiez, pourquoi vous pensiez que ça allait marcher, le schéma fonctionnel est parfait....

Et le code n'est pas familier avec la Bible dans une langue qui n'est pas familière, bien sûr, difficile à comprendre.

[Maxim Dmitrievsky]

mytarmailS:

Sérieusement ? ))))) Tu te moques de moi ou quoi ? ))

C'est pourquoi je vous dis ce que vous attendiez et pourquoi vous pensiez que ça marcherait...

Il est difficile de comprendre le code dans un langage qui ne vous est pas familier.

Je veux dire, tu te moques de moi ?