Aprendizaje automático en el trading: teoría, práctica, operaciones y más - página 2251

[mytarmailS]

Maxim Dmitrievsky:

la asignación de la serie a otro espacio (¿distribución?)

Sí, a otro espacio, no sé si a la distribución...

¿por qué etiquetas de clase? ¿por qué codificadores?

[Maxim Dmitrievsky]

mytarmailS:

Sí, a otro espacio, no sé si a la distribución...

¿por qué etiquetas de clase? ¿por qué codificadores?

se necesitan buenas muestras de venta y de compra, por eso las etiquetas

que es la distribución de los puntos en ese espacio, normalmente se elige la normal multivariante.

probablemente no funcione, pero es divertido.

¿qué se hace si el año que viene cambia el patrón? nada, no se puede sacar del año en curso

Hay que tomar todo el historial, dividirlo en clusters, igualar el número de muestras en cada cluster, luego generar ejemplos a partir de ellos y entrenarlos. Esto será +- constante, en teoría.

[mytarmailS]

Maxim Dmitrievsky:

necesita buenos ejemplos de venta y compra, por lo que las marcas

son la distribución de puntos en este espacio, normalmente ..............

Pues sí, estoy de acuerdo en que la idea concreta es tan-so....

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

¿Cuál es su robot en las distribuciones?

[Maxim Dmitrievsky]

mytarmailS:

Pues sí, estoy de acuerdo en que la idea concreta es tan-so....

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

¿Cuál es su robot en las distribuciones?

es una idea genial, sobre datos normales, no aleatorios.

Sólo funciona con euros, no tanto con otros.

Yo uso coder en lugar de gmm, no lo he hecho todavía.

[34767361]

¿Instrumento de prikrepiti BTC/USD?

[Maxim Dmitrievsky]

codificador en lugar de gmm. Formación 2 meses, prueba 5 años.

Es un poco más difícil captar la arquitectura. Una sola capa no funcionó del todo bien, añadí una segunda capa y mejoró

las capas normales de avance.

[mytarmailS]

Maxim Dmitrievsky:

codificador en lugar de gmm. Formación 2 meses, prueba 5 años.

Es un poco más difícil captar la arquitectura. Una sola capa no funcionó del todo bien, añadí una segunda capa y mejoró

Los estratos habituales de la alimentación.

Tengo la sensación de que el gráfico es más suave con gmm...

¿Por qué hay una neurona en absoluto puede explicar con un diagrama de bloques?

una sola capa sólo puede resolver problemas lineales

[Maxim Dmitrievsky]

mytarmailS:

Me parece que el gráfico de gmm es más suave...

¿Por qué hay una neurona, puedes explicar el diagrama de bloques?

Una capa sólo puede resolver problemas lineales

Esperaba más de ellos

el codificador es una neurona

no entenderás nada de todos modos, pero esta es la estructura de la misma

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:

el codificador es una neurona.

¿en serio? ))))) ¿me estás tomando el pelo o qué? ))

Maxim Dmitrievsky:

no lo entenderías.

Por eso te digo que me digas qué esperabas, por qué pensabas que iba a funcionar, el diagrama de bloques es perfecto...

Y el código no está familiarizado con la Biblia en un idioma que no es familiar, por supuesto, difícil de entender.

[Maxim Dmitrievsky]

mytarmailS:

¿En serio? ))))) ¿Me estás tomando el pelo o qué? ))

Por eso te digo simplemente lo que esperabas, por qué pensabas que iba a funcionar, el circuito es perfecto...

Es difícil entender el código en un lenguaje con el que no estás familiarizado.

Quiero decir, ¿me estás tomando el pelo?