交易中的机器学习：理论、模型、实践和算法交易 - 页 2268

[[删除]]

mytarmailS:

我不知道如何使用MICL（（）。

5K培训生

40K测试

试着将我的标准应用于你的GMM，应该能更好地找到工作模式

我已经在使用R^2了。

我得到了同样的漩涡，只是更好 )

[Rorschach]

Maxim Dmitrievsky:

一切都和往常一样，只是记下了平均的标记。那里有一个完全不同的布局，这很有趣

我最近发了一本书，其中一个有趣的想法是根据经典的方法设置网络权重，然后通过训练来微调它。我想知道是否有办法将训练与教师和强化相结合

[[删除]]

Rorschach:

我最近发了一本书，其中一个有趣的想法是按照经典的方法设置网络权重，然后通过训练进行微调。我想知道是否有办法将训练与教师和强化训练结合起来。

这些都是马什卡的诡异的类似物

[Rorschach]

Maxim Dmitrievsky:

这些都是maschka的复杂类似物。

网格有非线性的优势，以及选择参数的方式，但它们是相同的过滤器。

只是有很多关于强化学习 的负面情绪。在汽车中，有教师的网显示出更好的效果，在游戏中也是如此。他们甚至发明了一个网格，从一个关卡的末尾开始训练，并重新安排接近起点的产卵。这也很有趣，datasynth的经验决定了。Unity专门为ML做了一个游戏，并设立了一个冠军。人平均能到20级。他们在网格上采取了2种最新的方法，在他们的帮助下，他们平均达到了4级。而专家们能够在男人的水平上显示出结果。

[[删除]]

Rorschach:

网格有非线性的优势，以及选择参数的方式，但它们是相同的过滤器。

只是有很多关于强化学习的负面情绪。在汽车上，有老师的网表现出更好的效果，游戏也是如此。他们甚至发明了一张网，从关卡的末端开始训练，并重新安排靠近起点的产卵。这也很有趣，datasynth的经验决定了。Unity专门为ML做了一个游戏，并设立了一个冠军。人平均能到20级。他们在网格上采取了2种最新的方法，在他们的帮助下，他们平均达到了4级。而冠军赛的专家们能够在人的层面上展示成果。

我曾有过一次RL的炒作，但现在已经消失了......变压器和GANs现在是趋势了。

[mytarmailS]

Maxim Dmitrievsky:

曾经有一个RL的炒作，但现在已经结束了......变压器和GANs现在是趋势。

大脑正在成为趋势！他们知道所有的算法，知道如何将特定的算法应用于特定的任务，而不是追逐趋势。

如果你需要在GO中获胜，那么为什么要用GAN？ 如果你需要对Irises进行分类，那么为什么要用RL？

呵呵，凡事都有它的位置!

[[删除]]

mytarmailS:

在趋势是大脑！他们知道所有的算法，并知道如何将特定的算法应用于特定的任务，而不是追逐趋势....。

如果你需要在GO中获胜，为什么还要用GAN？ 如果你需要对Irises进行分类，为什么还要用RL？

万物有灵

你的心胸狭小，所以你看不到哪里，也不知道为了什么。

[Rorschach]

Maxim Dmitrievsky:

曾有过一次炒作，现在已经结束了。 变形金刚和高考正在流行。

GANs在生成人工数据方面是一个有趣的尝试。

我认为掌握这个框架 是个好主意，那么一切都会快很多。

[[删除]]

Rorschach:

产生人工数据的方法是有趣的尝试

我应该掌握这个框架 ，那么一切都会更快。

我写了我的甘，这没有什么复杂的。但它不是递归的，我得重新做。

关于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}")

下面是另一个例子

[[删除]]

如果你不想写任何东西，现成的