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

新评论
 
Maxim Dmitrievsky:

将该系列映射到另一个空间（分配？）

是的，到另一个空间，我不知道分配...

为什么是类标签？ 为什么是编码员？

 
mytarmailS:

是的，到另一个空间，我不知道分配...

为什么是类标签？ 为什么是编码员？

你需要好的销售样品和购买样品，这就是标签的原因。

即该空间中的点的分布，通常选择多变量正态。

它可能不会工作，但它很有趣。

如果明年模式改变了，你会怎么做？ 没有，你不能把它从这一年中弄出来。

你必须采取整个历史，将其分解成群组，均衡每个群组中的样本数量，然后从这些样本中生成例子并训练它们。从理论上讲，这将是+-稳定的。

 
Maxim Dmitrievsky:

你需要好的卖出和买入的例子，所以分数

是这个空间中的点的分布，通常..............

嗯，是的，我同意具体的想法是这样的--....

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

你在分配上的机器人是什么？

 
mytarmailS:

嗯，是的，我同意具体的想法是这样的--....

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

你的机器人在分配上是什么？

这是一个很酷的想法，在正常数据上，不是随机的。

它只对欧元有效，对其他国家就不太适用。

我使用coder而不是gmm，我还没有做过。

 

Kak prikrepiti instrument BTC/USD?

 

coder，而不是gmm。培训2个月，测试5年。

拾起建筑，就有点难了。单层的效果一点也不好，加了第二层，就好了。

正常的前馈层。

 
Maxim Dmitrievsky:

coder，而不是gmm。培训2个月，测试5年。

拾起建筑，就有点难了。单层的效果一点也不好，加了第二层，就好了。

通常的前馈层。

我有一种感觉，用gmm的图形更平滑...

为什么会有一个神经元，你能用方框图解释一下吗？


单层只能解决线性问题

 
mytarmailS:

在我看来，gmm图更平滑 ...

为什么会有一个神经元，你能解释一下方框图吗？


一层只能解决线性问题

我对他们的期望更高

编码器是一个神经元

反正你什么都不懂，但它的结构是这样的

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:

真的吗？))))) 你是在跟我开玩笑还是什么？))

这就是为什么我告诉你，你所期望的，以及你为什么认为会成功......

要理解你不熟悉的语言的代码是很难的。

我的意思是，你在跟我开玩笑吗？

1...224422452246224722482249225022512252225322542255225622572258...3399
新评论