Aprendizado de máquina no trading: teoria, prática, negociação e não só - página 2251

[mytarmailS]

Maxim Dmitrievsky:

mapeando a série para outro espaço (distribuição?)

Sim, para outro espaço, eu não sei sobre distribuição...

Porquê etiquetas de classe? Porquê codificadores?

[[Excluído]]

mytarmailS:

Sim, para outro espaço, eu não sei sobre distribuição...

Porquê etiquetas de classe? Porquê codificadores?

você precisa de boas amostras para vender e comprar, é por isso que as etiquetas

que é a distribuição dos pontos nesse espaço, normalmente é escolhida a normal multivariada.

provavelmente não vai funcionar, mas é divertido.

o que fazer se no próximo ano o padrão mudar? nada, você não pode tirá-lo do ano corrente

É preciso pegar o histórico inteiro, dividi-lo em clusters, equalizar o número de amostras em cada cluster, depois gerar exemplos a partir deles e treiná-los. Isto será +- constante, em teoria.

[mytarmailS]

Maxim Dmitrievsky:

você precisa de bons exemplos de venda e compra, por isso as marcas

são a distribuição de pontos neste espaço, normalmente ..............

Bem, sim, eu concordo que a ideia específica é tão ou tão....

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

Qual é o seu robô nas distribuições?

[[Excluído]]

mytarmailS:

Bem, sim, eu concordo que a ideia específica é tão ou tão....

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

Qual é o seu robô nas distribuições?

é uma ideia fixe, sobre dados normais, não aleatórios.

Funciona apenas em euros, não tanto em outros.

Eu uso codificador em vez de gmm, eu ainda não o fiz.

[34767361]

Instrumento Kak prikrepiti BTC/USD?

[[Excluído]]

codificador em vez de gmm. Treino 2 meses, teste 5 anos.

É um pouco mais difícil pegar na arquitectura. Uma camada não funcionou bem, acrescentando uma segunda camada, ficou melhor

camadas de alimentação normal.

[mytarmailS]

Maxim Dmitrievsky:

codificador em vez de gmm. Treino 2 meses, teste 5 anos.

É um pouco mais difícil pegar na arquitectura. Uma camada não funcionou bem, acrescentando uma segunda camada, ficou melhor

As habituais camadas de alimentação.

Tenho a sensação de que o gráfico é mais suave com gmm...

Porque é que existe um neurónio, de todo, pode explicar com um diagrama de blocos?

uma única camada só pode resolver problemas lineares

[[Excluído]]

mytarmailS:

Parece-me que o gráfico gmm é mais suave...

Porque é que existe um neurónio, pode explicar o diagrama de blocos?

Uma camada só pode resolver problemas lineares

Eu esperava mais deles.

o codificador é um neurônio

você não vai entender nada de qualquer maneira, mas aqui está a estrutura

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:

o codificador é um neurónio.

A sério? ))))) Estás a brincar comigo ou quê? ))

Maxim Dmitrievsky:

você não entenderia.

É por isso que te estou a dizer, diz-me só o que esperavas, porque pensaste que ia funcionar, o diagrama de blocos é perfeito...

E o código não está familiarizado com a Bíblia numa língua que não é familiar, é claro, difícil de entender.

[[Excluído]]

mytarmailS:

A sério? ))))) estás a gozar comigo ou quê? ))

É por isso que te estou a dizer simplesmente o que esperavas, porque pensavas que ia funcionar, o circuito é perfeito...

É difícil entender o código numa língua com a qual não estás familiarizado.

Quer dizer, estás a brincar comigo?