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

[Maxim Dmitrievsky]

mytarmailS:

Eu mkl não posso fazer isso ((

Estagiário de 5k

teste 40k

Tente aplicar o meu critério com o seu gmm, deve ser melhor encontrar modelos de trabalho

Eu já estou usando R^2.

Eu só tenho os mesmos redemoinhos melhor )

[Rorschach]

Maxim Dmitrievsky:

tudo é igual ao habitual, apenas as marcas com a média em mente. Há lá um layout completamente diferente, o que é interessante

Recentemente publiquei um livro onde uma ideia interessante era definir pesos de rede de acordo com o método clássico, e depois afiná-lo com o treino. Será que há formas de combinar a formação com um professor e com o reforço

[Maxim Dmitrievsky]

Rorschach:

Recentemente publiquei um livro onde uma ideia interessante era definir pesos de rede de acordo com o método clássico e depois afinar com o treino. Será que existem formas de combinar a formação com um professor e com o reforço

todos estes são análogos enganados do mashka.

[Rorschach]

Maxim Dmitrievsky:

estes são todos analógicos sofisticados da maschka.

As grelhas têm a vantagem da não-linearidade e da forma como os parâmetros são seleccionados, mas são os mesmos filtros.

Há apenas muita negatividade na aprendizagem do reforço. Nos carros, as redes com um professor mostram melhores resultados, o mesmo nos jogos. Eles até inventaram uma grelha a partir do fim de um nível para treinar e reordenar a desova mais perto do início. Também é interessante, a experiência do datasynth decide. A Unidade fez um jogo especificamente para o ML e montou um campeonato. O homem em média chega ao nível 20. Eles levaram os 2 métodos mais recentes nas grelhas, com a sua ajuda atingiram o nível 4 em média. E os especialistas foram capazes de mostrar resultados ao nível de um homem.

[Maxim Dmitrievsky]

Rorschach:

As grelhas têm a vantagem da não-linearidade e da forma como os parâmetros são seleccionados, mas são os mesmos filtros.

Há apenas muita negatividade na aprendizagem do reforço. Nos carros, as redes com um professor mostram melhores resultados, e os jogos também. Eles até inventaram uma grelha a partir do fim de um nível para treinar e reordenar a desova mais perto do início. Também é interessante, a experiência do datasynth decide. A Unidade fez um jogo especificamente para o ML e montou um campeonato. O homem em média chega ao nível 20. Eles levaram os 2 métodos mais recentes nas grelhas, com a sua ajuda atingiram o nível 4 em média. E os especialistas do campeonato puderam mostrar resultados ao nível de uma pessoa.

Tive um hype RL, mas agora desapareceu... Transformadores e GANs estão a ter tendências agora.

[mytarmailS]

Maxim Dmitrievsky:

Houve uma propaganda de RL, mas agora acabou... os transformadores e os GANs estão a ter tendências agora.

Os cérebros são tendências! Eles conhecem todos os algoritmos e sabem como aplicar um algoritmo específico para uma tarefa específica, e não para perseguir tendências.

Se você precisa ganhar em GO, então por que se preocupar com GAN? Se você precisa classificar Irises, então por que se preocupar com RL?

heh, tudo tem o seu lugar!

[Maxim Dmitrievsky]

mytarmailS:

Na tendência está o cérebro! que conhece todos os algoritmos e sabe como aplicar um algoritmo específico a uma tarefa específica, em vez de perseguir tendências....

Se você precisa ganhar em GO, por que se preocupar com o GAN? Se você precisa classificar Irises, por que se preocupar com RL?

tudo tem o seu lugar!

Você tem uma mente pequena para não poder ver onde e para quê.

[Rorschach]

Maxim Dmitrievsky:

houve uma propaganda rl, agora acabou. transformadores e gaNs têm tendência

Os GANs são interessantes para tentar gerar dados artificiais

Acho que é uma boa ideia dominar esta estrutura , então tudo irá muito mais rápido.

[Maxim Dmitrievsky]

Rorschach:

gan para gerar dados artificiais é interessante tentar

É melhor eu dominar esta estrutura , assim tudo irá muito mais rápido.

Eu escrevi o meu gangue, não há nada de complicado nisso. Mas não é recorrente, vou ter de refazê-lo.

Exemplo na Torcha.

декларация

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

aqui vai outro exemplo

[Maxim Dmitrievsky]

Se não queres escrever nada, o ready-made