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

[Maxim Dmitrievsky]

mytarmailS:

No sé cómo mcl ((

5k aprendiz

Prueba de 40k

Intenta aplicar mi criterio con tu gmm, debería ser mejor encontrar modelos que funcionen

Ya estoy usando R^2.

Tengo los mismos remolinos solo que mejor )

[Rorschach]

Maxim Dmitrievsky:

todo es igual que siempre, sólo las marcas con el promedio en mente. Hay un diseño completamente diferente allí, que es interesante

Hace poco publiqué un libro en el que una idea interesante era establecer los pesos de la red según el método clásico, y luego afinarlos con el entrenamiento. Me pregunto si hay formas de combinar el entrenamiento con un profesor y con refuerzo

[Maxim Dmitrievsky]

Rorschach:

Hace poco publiqué un libro en el que una idea interesante era establecer los pesos de la red según el método clásico y luego afinarlos con el entrenamiento. Me pregunto si hay formas de combinar el entrenamiento con un profesor y con refuerzo

todos estos son análogos trucados de mashka

[Rorschach]

Maxim Dmitrievsky:

todos ellos son análogos sofisticados de la maschka.

Las rejillas tienen la ventaja de la no linealidad y la forma de seleccionar los parámetros, pero son los mismos filtros.

Hay mucha negatividad sobre el aprendizaje por refuerzo. En los coches, las redes con un profesor muestran mejores resultados, lo mismo en los juegos. Incluso inventaron una cuadrícula del final de un nivel para entrenar y reorganizar el spawn más cerca del principio. También es interesante, la experiencia del datasynth decide. Unity hizo un juego específicamente para ML y creó un campeonato. El hombre en promedio llega al nivel 20. Tomaron los 2 métodos más novedosos sobre rejillas, con su ayuda alcanzaron el nivel 4 de media. Y los expertos fueron capaces de mostrar resultados al nivel de un hombre.

[Maxim Dmitrievsky]

Rorschach:

Las rejillas tienen la ventaja de la no linealidad y la forma de seleccionar los parámetros, pero son los mismos filtros.

Hay mucha negatividad sobre el aprendizaje por refuerzo. En los coches, las redes con un profesor muestran mejores resultados, al igual que los juegos. Incluso inventaron una cuadrícula del final de un nivel para entrenar y reorganizar el spawn más cerca del principio. También es interesante, la experiencia del datasynth decide. Unity hizo un juego específicamente para ML y creó un campeonato. El hombre en promedio llega al nivel 20. Tomaron los 2 métodos más novedosos sobre rejillas, con su ayuda alcanzaron el nivel 4 de media. Y los expertos del campeonato fueron capaces de mostrar resultados a la altura de una persona.

Tuve un hype de RL pero ya se ha ido... Transformers y GANs son tendencia ahora.

[mytarmailS]

Maxim Dmitrievsky:

Hubo un hype de RL, pero ya se acabó... los transformers y los GAN son tendencia ahora.

Los cerebros son tendencia. Conocen todos los algoritmos y saben cómo aplicar un algoritmo específico a una tarea concreta, y no persiguen tendencias.

Si necesita ganar en GO, entonces para qué molestarse con GAN. Si necesita clasificar Iris, entonces para qué molestarse con RL.

je, ¡todo tiene su lugar!

[Maxim Dmitrievsky]

mytarmailS:

En la tendencia está el cerebro! que conoce todos los algoritmos y sabe cómo aplicar un algoritmo específico a una tarea concreta, en lugar de perseguir tendencias....

Si necesita ganar en GO, ¿por qué molestarse con GAN? Si necesita clasificar Iris, ¿por qué molestarse con RL?

¡todo tiene su lugar!

Tienes una mente pequeña por lo que no puedes ver dónde y para qué.

[Rorschach]

Maxim Dmitrievsky:

hubo un hype de rl, ya se acabó. transformers y gaNs son tendencia

Los GANs son interesantes para probar la generación de datos artificiales

Creo que es una buena idea dominar este marco , entonces todo irá mucho más rápido.

[Maxim Dmitrievsky]

Rorschach:

gan para generar datos artificiales es interesante para probar

Será mejor que domine este marco , así todo irá mucho más rápido.

Yo escribí mi gan, no hay nada complicado en ello. Sin embargo, no es recursivo, tendré que rehacerlo.

Ejemplo en Antorcha.

декларация

#  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}")

aquí hay otro ejemplo

[Maxim Dmitrievsky]

Si no quiere escribir nada, la lista