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

[mytarmailS]

Maxim Dmitrievsky:

mappare la serie in un altro spazio (distribuzione?)

Sì, in un altro spazio, non conosco la distribuzione...

perché le etichette di classe? perché i codificatori?

[Maxim Dmitrievsky]

mytarmailS:

Sì, in un altro spazio, non conosco la distribuzione...

perché le etichette di classe? perché i codificatori?

avete bisogno di buoni campioni di vendita e di acquisto, ecco perché le etichette

cioè la distribuzione dei punti in quello spazio, di solito si sceglie la normale multivariata.

Probabilmente non funzionerà, ma è divertente.

Cosa fai se l'anno prossimo il modello cambia? niente, non puoi tirarlo fuori dall'anno in corso

Bisogna prendere l'intera storia, scomporla in cluster, equalizzare il numero di campioni in ogni cluster, poi generare esempi da essi e addestrarli. Questo sarà +- costante, in teoria.

[mytarmailS]

Maxim Dmitrievsky:

avete bisogno di buoni esempi di vendita e di acquisto, quindi i marchi

sono la distribuzione dei punti in questo spazio, di solito ..............

Beh sì, sono d'accordo che l'idea specifica è così-so....

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

Qual è il tuo robot sulle distribuzioni?

[Maxim Dmitrievsky]

mytarmailS:

Beh sì, sono d'accordo che l'idea specifica è così-so....

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

Qual è il tuo robot sulle distribuzioni?

è una bella idea, su dati normali, non casuali.

Funziona solo sugli euro, non tanto sugli altri.

Io uso coder invece di gmm, non l'ho ancora fatto.

[34767361]

Kak prikrepiti strumento BTC/USD?

[Maxim Dmitrievsky]

codificatore invece di gmm. Formazione 2 mesi, test 5 anni.

È un po' più difficile prendere l'architettura. Uno strato singolo non ha funzionato affatto bene, ho aggiunto un secondo strato, ed è andata meglio

normali strati feedforward.

[mytarmailS]

Maxim Dmitrievsky:

codificatore invece di gmm. Formazione 2 mesi, test 5 anni.

È un po' più difficile prendere l'architettura. Il singolo strato non ha funzionato bene per niente, ho aggiunto un secondo strato ed è andata meglio

I soliti strati feedforward.

Ho la sensazione che il grafico sia più fluido con gmm...

Perché c'è un neurone, puoi spiegarlo con un diagramma a blocchi?

un singolo strato può risolvere solo problemi lineari

[Maxim Dmitrievsky]

mytarmailS:

Mi sembra che il grafico gmm sia più liscio...

Perché c'è un neurone, puoi spiegare il diagramma a blocchi?

Uno strato può risolvere solo problemi lineari

Mi aspetterei di più da loro

il codificatore è una neuronica

non capirete nulla comunque, ma ecco la struttura

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:

il codificatore è un neurone.

Sul serio? ))))) mi prendi in giro o cosa? ))

Maxim Dmitrievsky:

non capireste.

È per questo che ti dico, dimmi solo cosa ti aspettavi, perché pensavi che avrebbe funzionato, lo schema a blocchi è perfetto...

E il codice non ha familiarità con la Bibbia in una lingua che non è familiare, ovviamente, difficile da capire.

[Maxim Dmitrievsky]

mytarmailS:

Davvero? ))))) Mi stai prendendo in giro o cosa? ))

Ecco perché ti dico cosa ti aspettavi e perché pensavi che avrebbe funzionato...

È difficile capire il codice in una lingua che non si conosce.

Voglio dire, mi stai prendendo in giro?