文章 "神经网络变得简单（第 57 部分）：随机边际扮演者-评论者（SMAC）"

新评论
 

新文章 神经网络变得简单（第 57 部分）：随机边际扮演者-评论者（SMAC）已发布：

在此，我将研究相当新颖的随机边际扮演者-评论者（SMAC）算法，该算法允许在熵值最大化的框架内构建潜在变量政策。

在构建自动交易系统时，我们开发了制定后续决策的算法。强化学习方法正是为了解决这些问题。强化学习的关键问题之一是如同智能体学习与环境交互那般的探索过程。在这种前后呼应情况下，经常运用最大熵原理，这促使智能体按最大随机度执行动作。然而，在实践中，这种算法只能训练简单的智能体学习单个动作周围的局部变化。这是因为需要计算智能体政策的熵值，并将其用作训练目标的一部分。

同时，提高扮演者政策表现力的一种相对简单的方式是使用潜在变量，其为智能体提供了自己的模型随机性推理过程，手段则是观察、环境和未知奖励。


将潜在变量引入智能体的政策，令其能够涵盖更多样化的场景，且与历史观测兼容。这里应该注意的是，具有潜在变量的政策不允许使用简单的表达式来判定它们的熵。朴素的熵估值可能会导致灾难性的政策优化失败。此外，熵最大化的高方差随机更新无法轻易区分局部随机效应和多模态探索。

在《潜在状态边际化作为改进探索的低成本方法》一文中提出了解决这些潜在可变政策缺陷的方案之一。作者提出了一种《简单而有效的政策优化算法，能够在完全可观察和部分可观察的环境中提供更高效和更强大的探索。

作者：Dmitriy Gizlyk

 
未编译。
附加的文件：
2023-09-06_12-25-50.png  156 kb
 
我也没有编译。同样的事情。
 
star-ik #:
未编译。

文章中的文件档案已更新。

 

德米特里，感谢你的辛勤工作。一切正常。

我用 Expert Advisor Research 收集了100 个 例子 ，用 Expert Advisor Study 训练模型，用 Test 测试。然后，我再次收集 50 个示例，迭代训练 10 000 次，再次测试。

如此反复，直到模型学会为止。不过，到目前为止，测试在循环后不断给出不同的结果，而且并不总是正面的。我运行了一个周期，进行了 2-3 次测试，结果都不一样。

在哪个周期内结果会变得稳定？还是说这是一项无休止的工作，结果总是不同？

谢谢！

 
Nikolai Fedotov 我用 Expert Advisor Research 收集了100 个 例子 ，用 Expert Advisor Study 训练模型，用 Test 测试。然后，我再次收集 50 个示例，迭代训练 10 000 次，再次测试。

如此反复，直到模型学会为止。不过，到目前为止，测试在循环后不断给出不同的结果，而且并不总是正面的。也就是说，我运行一个循环，进行 2-3 次测试，结果都不一样。

在哪个周期内结果会趋于稳定？还是说这是一项无休止的工作，结果总是不同？

谢谢！

Expert Advisor 采用随机策略训练模型。这意味着，该模型会学习在系统的特定状态下采取特定行动时获得最大回报的概率。在与环境交互的过程中，会根据学习到的概率对行动进行采样。在初始阶段，所有行动的概率都是相同的，模型会随机选择一个行动。在学习过程中，概率会发生变化，行动的选择也会更加有意识。

 

德米特里，您好！如尼古拉所述，您花了多少个周期才获得稳定的正结果？

另一个有趣的问题是，如果 Expert Advisor 在当前阶段进行学习，而一个月后需要根据新数据对其进行重新训练，那么是完全重新训练还是在学习之前重新训练？训练过程是与初始过程类似，还是更短更快？还有，如果我们已经在欧元兑美元上训练了一个模型，那么在英镑兑美元上工作时，它将与初始模型一样需要重新训练，还是在训练前重新训练会更快？这个问题不是针对你们的这篇文章，而是针对你们所有基于强化学习 原理工作的智能交易系统。

 

日安

迪米特里，谢谢你的工作。

我想向大家澄清...

迪米特里发布的不是 "圣杯"。

它是一个典型的学术问题， 意味着 为理论和方法论性质的科学研究 活动做准备。

每个人都希望在自己的账户上看到积极的结果，就在此时此地....。

德米特里教我们如何用德米特里提出的所有方法解决（我们/我/你/他们）的问题。

流行人工智能（GPT）拥有超过 7 亿个参数!!!!这个人工智能值多少钱？

如果您想得到好结果，请交流想法（添加参数）、给出测试结果 等。

创建一个单独的聊天室，在那里 "获取 "结果。您可以在这里吹嘘 :-)，从而展示德米特里的工作成效...

 
Oleg_Filatov 测试结果 等。

创建一个单独的聊天室，在那里 "获取 "结果。您可以在这里吹嘘 :-)，从而展示德米特里工作的成效...

伙计，没有人在这里等待圣杯！我只是想看看德米特里的成果是否真的有效。不是从德米特里的文章中（他的所有文章都有几乎正面的结果），而是在我的电脑上。我从这篇文章中下载了他的智能交易系统（Expert Advisor），并且已经进行了 63 个周期的训练（数据收集 -> 训练）。结果还是亏损。在所有 63 个周期中，只有几次数据收集，在 50 个新示例中，有 5-6 个是正值，其他都是负值。我怎么才能知道它真的有效呢？

我在上面的帖子里问过德米特里，他什么也没回答。其他文章中也有同样的问题--无论如何训练都没有结果.....。

朋友，如果你得到了一个稳定的结果，那么请写出在得到稳定结果之前你做了多少个循环，比如在这篇文章中？如果要改，改什么才能在你的电脑上看到结果？不是圣杯，但至少可以看到它的工作原理......？

 
Oleg_Filatov 测试结果 等。

请创建一个单独的聊天室，在那里 "获取 "结果。您可以在这里吹嘘 :-)，从而展示德米特里的工作成效......

享受 <3

以下是参数：（基于 Dmitry 和一些研究）
// RSI 的输入参数
输入组 "---- RSI ----"
输入 int RSIPeriod = 14; // 周期
输入 ENUM_APPLIED_PRICE RSIPrice = PRICE_CLOSE; // 应用价格

// CCI 的输入参数
输入组 "---- CCI ----"
输入 int CCIPeriod = 14; // 周期
输入 ENUM_APPLIED_PRICE CCIPrice = PRICE_TYPICAL; // 应用价格

// ATR 的输入参数
输入组 "---- ATR ----"
输入 int ATRPeriod = 14; // 周期

// MACD 的输入参数
输入组 "---- MACD ----"
输入 int FastPeriod = 12; // 快速
输入 int SlowPeriod = 26; // 慢速
输入 int SignalPeriod = 9; // 信号
输入 ENUM_APPLIED_PRICE MACDPrice = PRICE_CLOSE; // 应用价格

// 动量输入参数
输入组 "---- Momentum ----"
输入 int MomentumPeriod = 14; // 动量周期
输入 ENUM_APPLIED_PRICE AppliedPrice = PRICE_CLOSE; // 动量的应用价格

// SAR 的输入参数
输入组 "---- SAR ----"
输入 float SARStep = 0.02f; // SAR 步长
输入 float SARMaximum = 0.2f; // SAR 最大值

// 频段输入参数
输入组 "---- 频段 ----"
输入 int BandsPeriod = 20; // 波段周期
input int BandsDeviation = 2.0; // 波段偏差
input int BandsShift = 0; // 频段偏移

#include "FQF.mqh"
//---
#define HistoryBars 72 //历史深度
#define BarDescr 14 // 单条描述的元素
#define AccountDescr 12 //账户描述
#define NActions 6 //可能的行动数
#define NRewards 5 //奖励数量
#define EmbeddingSize 64
#define Buffer_Size 6500
#define DiscFactor 0.99f
#define FileName "zJimReaper_NNM_Neural_Network_" #define LatentLayer 11
#define LatentLayer 11
#define LatentCount 2048
#define SamplLatentStates 32
#define MaxSL 1000
#define MaxTP 1000
#define MaxReplayBuffer 500
#define StartTargetIteration 50000
#define fCAGrad_C 0.5f
#define iCAGrad_Iters 15
#define KNN 32
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
bool CreateDescriptions(CArrayObj *actor, CArrayObj *critic, CArrayObj *convolution)
{
//---
CLayerDescription *descr；
//---
if(!actor)
{
actor = new CArrayObj()；
if(!actor)
返回 false；
}
if(!critic)
{
critic = new CArrayObj()；
if(!critic)
return false；
}
if(!convolution)
{
convolution = new CArrayObj()；
if(!convolution)
返回 false；
}
//--- Actor
actor.Clear()；
//--- 输入层
if (!(descr = new CLayerDescription()))返回 false；
descr.type = defNeuronBaseOCL；
int prev_count = descr.count = (HistoryBars * BarDescr)；
descr.activation = None；
descr.optimisation = ADAM.优化
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 1 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBatchNormOCL；
descr.count = prev_count；
descr.batch = 1000；
descr.activation = None；
descr.optimisation = ADAM；
如果(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 2 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronConvOCL；
prev_count = descr.count = BarDescr；
descr.window = HistoryBars；
descr.step = HistoryBars；
int prev_wout = descr.window_out = HistoryBars / 2；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 3 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronConvOCL；
prev_count = descr.count = prev_count - 1；
descr.window = 7；
descr.step = 3；
descr.window_out = 32；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 4 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronConvOCL；
prev_count = descr.count = prev_count - 1；
descr.window = 5；
descr.step = 2；
descr.window_out = 16；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；


}信息长度不应超过 64000 个字符

 


//--- 第 5 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronConvOCL；
prev_count = descr.count = prev_count - 1；
descr.window = 3；
descr.step = 1；
descr.window_out = 8；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 6 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronConvOCL；
prev_count = descr.count = BarDescr；
descr.window = HistoryBars；
descr.step = HistoryBars；
prev_wout = descr.window_out = HistoryBars / 2；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 7 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronConvOCL；
prev_count = descr.count = prev_count；
descr.window = prev_wout；
descr.step = prev_wout；
descr.window_out = 32；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 8 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = 2 * LatentCount；
descr.optimisation = ADAM；
descr.activation = LReLU；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 9 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
prev_count = descr.count = LatentCount；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 10 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronConcatenate；
descr.count = 4 * LatentCount；
descr.window = prev_count；
descr.step = AccountDescr；
descr.optimisation = ADAM；
descr.activation = SIGMOID；
如果(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 11 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronVAEOCL；
descr.count = 2 * LatentCount；
descr.optimise = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 12 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = 2 * LatentCount；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 13 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = LatentCount；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 14 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = LatentCount；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 15 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = 2 * NActions；
descr.activation = SIGMOID；
descr.optimisation = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 16 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronVAEOCL；
descr.count = NActions；
descr.optimise = ADAM；
if(!actor.Add(descr))
{
删除 descr；
返回 false；
}
//---批评者
critic.Clear()；
//--- 输入层
if (!(descr = new CLayerDescription()))返回 false；
descr.type = defNeuronBaseOCL；
prev_count = descr.count = 2 * LatentCount；
descr.activation = None；
descr.optimisation = ADAM；
if(!critic.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 1 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronConcatenate；
descr.count = 2 * LatentCount；
descr.window = prev_count；
descr.step = NActions；
descr.optimisation = ADAM；
descr.activation = LReLU；
if(!critic.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 2 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = 2 * LatentCount；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!critic.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 3 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = LatentCount；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!critic.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 4 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = LatentCount；
descr.activation = LReLU；
descr.optimisation = ADAM；
if(!critic.Add(descr))
{
删除 descr；
返回 false；
}
//--- 第 5 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = NRewards；
descr.optimisation = ADAM；
descr.activation = None；
if(!critic.Add(descr))
{
删除 descr；
返回 false；
}
//--- 卷积
// 定义常用参数
int input_size = (HistoryBars * BarDescr) + AccountDescr；
int num_actions = NActions；
int embedding_size = EmbeddingSize；
// 创建神经网络
convolution.Clear()；
// 输入层 0
if (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = 4 * input_size；
descr.activation = None；
descr.optimisation = ADAM；
如果 (!convolution.Add(descr))
{
删除 descr；
返回 false；
}
// 第 1 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = 2 * LatentCount；
descr.window = 2 * input_size；
descr.step = 2 * num_actions；
descr.activation = SIGMOID；
descr.optimisation = ADAM；
如果 (!convolution.Add(descr))
{
删除 descr；
返回 false；
}
// 第 2 层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = LatentCount；
descr.window = input_size；
descr.step = num_actions；
descr.activation = SIGMOID；
descr.optimisation = ADAM；
如果 (!convolution.Add(descr))
{
删除 descr；
返回 false；
}
// 卷积层
for (int i = 0; i < 6; i++)
{
if (!(descr = new CLayerDescription()))返回 false；
descr.type = defNeuronConvOCL；
descr.count = 2 * LatentCount / (1 << i); // 将每一层的计数减半
descr.window = 64；
descr.step = 64；
descr.window_out = 32 / (1 << i); // 窗口输出减半
descr.activation = LReLU；
descr.optimisation = ADAM；
if (!convolution.Add(descr))
{
删除 descr；
返回 false；
}
}
// 输出层
如果 (!(descr = new CLayerDescription())返回 false；
descr.type = defNeuronBaseOCL；
descr.count = embedding_size；
descr.activation = LReLU；
descr.optimisation = ADAM；
如果 (!convolution.Add(descr))
{
删除 descr；
返回 false；
}
// 成功创建网络
return true；
}
#ifndef Study
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
bool IsNewBar(void)
{
=== 由于注释 限制在 64000 个字符以内，我删掉了最后一部分，但你知道该怎么做...=)
信息长度不应超过 64000 字符

-----------------------------------------------------+


12
新评论