奖励与精细惩罚

摘要

本来只是想记下除了对不满足要求的action进行惩罚外，还应该对剩余部分进行奖励，这样才能使训练易收敛。但对比softmax，总觉得只用惩罚，应该也能够达到要求。后面试着用更细致的惩罚进行训练，发现也可以取得类似的效果。虽然训练收敛性能可能不是那么完美，但得到的模型却能观察到多样性的输出。

奖励的策略

需要测试模型能否达到每步输出不同决策。比如输出的决策序列集是(横向是步数，纵向是样本，对output reshape至三维，argmax后得到二维):

[[  6.  11.   8.   1.  17.  17.   2.   1.   1.   9.]
 [ 14.   6.   8.   6.   5.   2.   2.   2.   6.  12.]
 [ 17.   0.   7.   9.  17.   2.   8.   1.  14.  11.]
 [ 17.   7.   0.   1.  17.  16.   8.   9.  19.  12.]
 [ 19.  19.   8.   9.  17.   1.   2.   1.   7.  15.]]
# 那么需要惩罚的位置是以下负数所在:
[[-0.     -0.     -0.   -.25  -.13  -.13  -0.    -.25  -.25  -0.        ]
 [-0.     -.17   -0.  -.17   -0.    -.17  -.17  -.17  -.17  -0.        ]
 [-0.5   -0.     -0.  -0.     -0.5  -0.    -0.     -0.   -0.    -0.        ]
 [-0.5   -0.     -0.  -0.     -0.5  -0.    -0.     -0.   -0.    -0.        ]
 [-.25   -.25   -0.  -0.     -0.    -.25  -0.     -.25 -0.    -0.        ]]

但这样的结果是，损失函数(对每个样本(每行)重复元素的统计)早期可以下去，但之后突然上升一直到模型输出全部元素相同的矩阵。并且调整学习率，梯度剪切都没用。

batch	49	99	149	199	249	299	349	2649	52399	52449	52499
ADAM	3.10906	0.76629	0.08666	0.127979	0.55575	4.77797	2.98737	9.57556	9.99666	9.98229	9.99041

想到换个求解器从adam换到sgd，但速度太慢，觉得这样即使做出来，也难以用上:

batch	49	99	149	199	249	299	349	399	449	499
SGD	3.415480	3.298667	3.305875	3.331791	3.360458	3.383812	3.396730	3.411167	3.395938	3.399229
最后是对没有产生与重复约束冲突的位置进行奖励，获得了效果。

[[ 0.0625      0.0625      0.0625     -0.1875     -0.0625     -0.0625
   0.0625     -0.1875     -0.1875      0.0625    ]
 [ 0.04545455 -0.13636364  0.04545455 -0.13636364  0.04545455 -0.13636364
  -0.13636364 -0.13636364 -0.13636364  0.04545455]]
[[-0.1         0.1         0.1         0.1        -0.1         0.1         0.1
   0.1         0.1         0.1       ]
 [-0.1         0.1         0.1         0.1        -0.1         0.1         0.1
   0.1         0.1         0.1       ]
 [-0.1        -0.1         0.1         0.1         0.1        -0.1         0.1
  -0.1         0.1         0.1       ]]

batch	49	99	149	199	249	299	349	399	449	499	549
ADAM	0.21670	0.00029	0.00066	0.00008	0.00037	0.00016	0.00020	0.00000	0.00016	0.00000	0.00000

可以猜测到模型输出的一些特性:

[[ 17.  11.  10.  14.   5.  16.   8.  18.  12.  15.]
 [  3.  15.   0.   6.  17.  16.   8.   9.  12.   4.]
 [ 17.  11.  10.  14.   5.  16.   8.  18.  12.  15.]
 [ 17.  11.  10.  14.   5.  16.   8.  18.  12.  15.]
 [  7.  15.  13.  14.   5.   2.   8.   9.  12.   4.]]

---

3.19的试验

惩罚策略

修正后的策略是，仅对第二次开始重复的元素进行惩罚。

# 决策序列如下
[[ 15.  18.   6.  19.   6.  15.   6.  19.   0.   5.]
 [ 13.   1.  17.   0.   7.   6.   9.  18.   3.   9.]
 [  4.   9.  15.   8.  17.   9.  13.   4.  11.  16.]
 [ 12.   0.  18.   3.  17.   9.   3.  10.  13.  18.]
 [  3.   1.   6.  16.   8.   2.  12.   0.   9.   8.]]
# 下列矩阵非0元素位置 作惩罚
 [[ 0.  0.  0.  0.  2.  1.  2.  1.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  1.]
 [ 0.  0.  0.  0.  0.  1.  0.  1.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.  1.  0.  0.  1.]
 [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  1.]]

迭代过程:

batch	49	99	149	199	249	299	349	399	449	499
ADAM	0.89072	0.07639	0.04589	0.03497	0.02870	0.02835	0.02600	0.02720	0.024646	0.03414

过程虽然没有达到完全状态，但还是良好。查看输出的结果样本:

[[  1.  13.   3.   0.   9.  19.   4.  17.   6.   7.]
 [ 17.  13.   4.  15.   1.   5.  10.  14.  19.   7.]
 [  1.  13.   3.   0.   9.  19.  10.  17.  11.   7.]
 [  1.  13.   3.   0.   9.  19.  10.  17.   6.   7.]
 [  1.  13.   3.   0.   9.  19.   4.  17.   6.  15.]]

对比下，还是能反映出这种策略的优势。