Python Pybrain-哪个重量属于哪个连接？

我和pybrain有点问题。我创建了一个简单的xor问题，并使用pybrain在不使用偏差的情况下解决它，然后使用一个简单的算法获得从一层到下一层的所有权重。这里一切正常，不需要知道哪个重量属于哪个连接

当我尝试用VHDL复制神经网络时，问题就出现了。我尝试过在许多组合中使用权重，但没有成功地按照正确的顺序使用它们（我最初认为问题在于VHDL代码，但后来我尝试手动执行相同的操作，但最终得到相同的结果）

网络看起来像这样

  c1/5-   O   c9- 
O c2/6-   O  c10-  O
O c3/7-   O  c11- 
  c4/8-   O  c12- 
in|hidden|out

O是神经元，cN是连接

获得的权重如下所示：

in->hidden0=>[-1.5370131 0.20571103-0.55526946 2.24190836 1.25758021 0.0099828 3.41607776 3.60830287]

hidden0->out=>[1.18471773-2.20053965-2.60886924 3.70095397]

我试着先用两种最明显的方式来唱：

    First combo|  Second combo

c1 -> -1.537     |     -1.53

c2 -> 0.206      |     1.257

c3 -> -0.555     |     0.205

c4 -> 2,242      |     0.0099

c5 -> 1.257      |     -0.555

c6 -> 0.0099     |     3.416

c7 -> 3.416      |     2.242

c8 -> 3.608      |     3.608

c9 -> 1.185      |     1.185

c10 -> -2.2      |     -2.2

c11 -> -2.609    |     -2.609

c12 -> 3.7       |     3.7

对于两个组合，我得到了大致相同的结果~0.5。 这意味着我使用重量的方式或者我做数学的方式绝对有问题

我用以下方法计算：

in -> hidden

suppose input "11"

1 * c1 + 1 * c2 = RES

output = sigmoid(RES)

1 * c3 + 1 * c4 = RES2

output2 = sigmoid(RES2)

and so on

hidden -> out

output * c9 = RES9

final = sigmoid(RES9)

output2 * c10 = RES10

final = sigmoid (RES10)

and so on

现在想象一下，我也尝试了另一种组合。上述组合为c1-c2，另一组合为c1-c5

我在这里用VHDL实现了相同的东西，结果与我手动获得的结果相同

为了验证我的VHDL代码，我需要正确的权重顺序。我知道这应该是可行的，因为我通过运行pybrain得到的结果是：

[1,0][0.95923448]

[0,1][0.95626049]

[0,0][0.03813141]

[1,1][0.05266151]

PS：我使用的xor就是在这个例子中得到的。我只修改了隐藏层中神经元的数量，将偏差修改为False，并使用hiddenclass=SigmoidLayer。获得权重的代码可以是以下2项中的任意一项：

第一个代码

for c in [connection for connections in net.connections.values() for connection in connections]:
print("{} -> {} => {}".format(c.inmod.name, c.outmod.name, c.params))

for mod in net.modules:
    print("Module:", mod.name)
    if mod.paramdim > 0:
        print("--parameters:", mod.params)
    for conn in net.connections[mod]:
        print("-connection to", conn.outmod.name)
        if conn.paramdim > 0:
             print("- parameters", conn.params)
    if hasattr(net, "recurrentConns"):
        print("Recurrent connections")
        for conn in net.recurrentConns:
            print("-", conn.inmod.name, " to", conn.outmod.name)
            if conn.paramdim > 0:
                print("- parameters", conn.params)

第二个代码

for c in [connection for connections in net.connections.values() for connection in connections]:
print("{} -> {} => {}".format(c.inmod.name, c.outmod.name, c.params))

for mod in net.modules:
    print("Module:", mod.name)
    if mod.paramdim > 0:
        print("--parameters:", mod.params)
    for conn in net.connections[mod]:
        print("-connection to", conn.outmod.name)
        if conn.paramdim > 0:
             print("- parameters", conn.params)
    if hasattr(net, "recurrentConns"):
        print("Recurrent connections")
        for conn in net.recurrentConns:
            print("-", conn.inmod.name, " to", conn.outmod.name)
            if conn.paramdim > 0:
                print("- parameters", conn.params)

---

这两个片段都是从stackoverflow问题中获得的。如果你愿意，我可以找他们并在这里发布链接

好的，我找到了我想要的答案

配重并排（c1-c2）。 这意味着正确的重量为：

c1 -> -1.537

c2 -> 0.206

c3 -> -0.555

c4 -> 2,242

c5 -> 1.257

c6 -> 0.0099

c7 -> 3.416

c8 -> 3.608

c9 -> 1.185

c10 -> -2.2

c11 -> -2.609

c12 -> 3.7

要获得正确的权重顺序，请执行以下操作：

for c in [connection for connections in net.connections.values() for connection in connections]:
        print("{} -> {} => {}".format(c.inmod.name, c.outmod.name, c.params))
        print("org {}", reshape(c.params, (c.outdim, c.indim)))

获取数据的代码是： 重塑（c.params，（c.outdim，c.indim）） 其中“c”是与神经元的连接

权重如下所示：

[[-1.537   0.206],
 [-0.555   2.242],
 [1.257    0.0099],
 [3.416    3.608]]

及

每一行都是与神经元的连接

例如：

Suppose input = "10"
1 * -1.537 + 0 * 0.206 
and then goes to the sigmoid function
and so on

我已经试过了，但没有成功，这是有道理的，因为我做错了。创建新网络时，可以向其传递一些参数，其中包括hiddenclass和outclass。我将hiddenclass设置为SigmoidLayer，但没有初始化outclass，它是用默认值LinearLayer初始化的。这意味着，当我用VHDL实现代码时，以及当我通过手工计算进行测试时，我正在做一个额外的sigmoid函数

如果有2个以上的输入连接到隐藏层，假设有4个，它将如下所示：

[[c1 c2 c3],
 [c4 c5 c6],
 [c7 c8 c9]]

等等

---

祝未来需要这个的人好运好的，我找到了我想要的答案

配重并排（c1-c2）。 这意味着正确的重量为：

c1 -> -1.537

c2 -> 0.206

c3 -> -0.555

c4 -> 2,242

c5 -> 1.257

c6 -> 0.0099

c7 -> 3.416

c8 -> 3.608

c9 -> 1.185

c10 -> -2.2

c11 -> -2.609

c12 -> 3.7

要获得正确的权重顺序，请执行以下操作：

for c in [connection for connections in net.connections.values() for connection in connections]:
        print("{} -> {} => {}".format(c.inmod.name, c.outmod.name, c.params))
        print("org {}", reshape(c.params, (c.outdim, c.indim)))

获取数据的代码是： 重塑（c.params，（c.outdim，c.indim）） 其中“c”是与神经元的连接

权重如下所示：

[[-1.537   0.206],
 [-0.555   2.242],
 [1.257    0.0099],
 [3.416    3.608]]

及

每一行都是与神经元的连接

例如：

Suppose input = "10"
1 * -1.537 + 0 * 0.206 
and then goes to the sigmoid function
and so on

我已经试过了，但没有成功，这是有道理的，因为我做错了。创建新网络时，可以向其传递一些参数，其中包括hiddenclass和outclass。我将hiddenclass设置为SigmoidLayer，但没有初始化outclass，它是用默认值LinearLayer初始化的。这意味着，当我用VHDL实现代码时，以及当我通过手工计算进行测试时，我正在做一个额外的sigmoid函数

如果有2个以上的输入连接到隐藏层，假设有4个，它将如下所示：

[[c1 c2 c3],
 [c4 c5 c6],
 [c7 c8 c9]]

等等

祝未来有需要的人好运