相关疑难解决方法(0)

这是我在ANSI C中的感知器实现:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

float randomFloat()
{
    srand(time(NULL));
    float r = (float)rand() / (float)RAND_MAX;
    return r;
}

int calculateOutput(float weights[], float x, float y)
{
    float sum = x * weights[0] + y * weights[1];
    return (sum >= 0) ? 1 : -1;
}

int main(int argc, char *argv[])
{
    // X, Y coordinates of the training set.
    float x[208], y[208];

    // Training set outputs.
    int outputs[208];

    int i = 0; // iterator

    FILE *fp;

    if …

我有一个简单的NN模型,用于检测使用Keras(Theano后端)在python中编写的28x28px图像的手写数字:

model0 = Sequential()

#number of epochs to train for
nb_epoch = 12
#amount of data each iteration in an epoch sees
batch_size = 128

model0.add(Flatten(input_shape=(1, img_rows, img_cols)))
model0.add(Dense(nb_classes))
model0.add(Activation('softmax'))
model0.compile(loss='categorical_crossentropy', 
         optimizer='sgd',
         metrics=['accuracy'])

model0.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch,
      verbose=1, validation_data=(X_test, Y_test))

score = model0.evaluate(X_test, Y_test, verbose=0)

print('Test score:', score[0])
print('Test accuracy:', score[1])

运行良好,我的准确度达到了90%.然后,我执行以下命令,通过执行操作获取网络结构的摘要print(model0.summary()).这输出如下:

Layer (type)         Output Shape   Param #     Connected to                     
=====================================================================
flatten_1 (Flatten)   (None, 784)     0           flatten_input_1[0][0]            
dense_1 (Dense)     (None, 10)       7850        flatten_1[0][0]                  
activation_1        (None, 10)          0           dense_1[0][0] …

多层感知器神经网络中的隐藏层数对神经网络的行为方式有何影响？隐藏层中节点数量的问题相同？

假设我想使用神经网络进行手写字符识别.在这种情况下,我将像素颜色强度值作为输入节点,将字符类作为输出节点.

我如何选择隐藏层和节点的数量来解决这个问题？

我有以下代码,来自PyBrain教程:

from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure.modules import TanhLayer

ds = SupervisedDataSet(2, 1)
ds.addSample((0,0), (0,))
ds.addSample((0,1), (1,))
ds.addSample((1,0), (1,))
ds.addSample((1,1), (0,))

net     = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, ds)

for inp, tar in ds:
     print [net.activate(inp), tar]

errors  = trainer.trainUntilConvergence()

for inp, tar in ds:
     print [net.activate(inp), tar]

然而,结果是一个训练不好的神经网络.在查看错误输出时,网络会得到正确的训练,但是它会使用'continueEpochs'参数来训练更多,并且网络再次表现更差.因此网络正在融合,但没有办法获得训练有素的网络.PyBrain的文档意味着返回的网络被训练得最好,但它会返回一个错误元组.

当我将continueEpochs设为0时,我得到一个错误(ValueError:max()arg是一个空序列)所以continueEpochs必须大于0.

是否实际维护了PyBrain,因为它似乎在文档和代码方面存在很大差异.

我想制作一个模型来预测输入信号的未来响应,我的网络架构是[3,5,1]:

• 3输入,
• 隐藏层中的5个神经元,和
• 输出层中有1个神经元.

我的问题是:

1. 我们应该为每个隐藏和输出层分别使用BIAS吗？
2. 我们是否应该在每一层为BIAS分配权重(因为BIAS会成为我们网络的额外价值并导致网络负担过重)？
3. 为什么BIAS总是设置为1？如果eta具有不同的值,为什么我们不将BIAS设置为不同的值？
4. 为什么我们总是将log sigmoid函数用于非线性函数,我们可以使用tanh吗？

我无法理解反向传播算法.我阅读了很多并搜索了很多,但我无法理解为什么我的神经网络不起作用.我想确认我正在以正确的方式做所有事情.

这里是我的神经网络,当它被初始化,当输入的第一线[1,1]和输出[0]设置(因为你可以看到,我试图做XOR神经网络):

我有3层:输入,隐藏和输出.第一层(输入)和隐藏层包含2个神经元,其中每个神经元有2个突触.最后一层(输出)也包含一个神经元,也有2个突触.

突触包含一个权重,它是前一个delta(在开头,它是0).连接到突触的输出可以与与synapse关联的sourceNeuron或者在input数组中找到,如果没有sourceNeuron(如在输入层中).

Layer.java类包含一个神经元列表.在我的NeuralNetwork.java中,我初始化神经网络,然后在我的训练集中循环.在每次迭代中,我替换输入和输出值,并调用对当前组在我的BP算法火车和(现在的1000倍历元)的算法运行一定数目的时间.

我使用的激活功能是sigmoid.

训练集和验证集是(input1,input2,output):

1,1,0
0,1,1
1,0,1
0,0,0

这是我的Neuron.java实现:

public class Neuron {

    private IActivation activation;
    private ArrayList<Synapse> synapses; // Inputs
    private double output; // Output
    private double errorToPropagate;

    public Neuron(IActivation activation) {
        this.activation = activation;
        this.synapses = new ArrayList<Synapse>();
        this.output = 0;
        this.errorToPropagate = 0;
    }

    public void updateOutput(double[] inputs) {
        double sumWeights = this.calculateSumWeights(inputs);

        this.output = this.activation.activate(sumWeights);
    }

    public double calculateSumWeights(double[] inputs) {
        double sumWeights = 0;

        int …

我知道在小型网络中需要偏置来改变激活函数。但是在具有多层 CNN、池化、dropout 和其他非线性激活的 Deep 网络的情况下，Bias 真的有所作为吗？ 卷积滤波器正在学习局部特征，并且对于给定的 conv 输出通道使用相同的偏差。

这不是这个链接的骗局。上述链接仅解释了偏差在小型神经网络中的作用，并没有试图解释偏差在包含多个 CNN 层、drop-outs、池化和非线性激活函数的深层网络中的作用。

我进行了一个简单的实验，结果表明从 conv 层去除偏差对最终测试精度没有影响。 训练了两个模型，测试准确率几乎相同（没有偏差的一个稍微好一点。）

• model_with_bias，
• model_without_bias（在conv层中没有添加偏差）

它们是否仅用于历史原因？

如果使用偏差不能提高准确性，我们不应该忽略它们吗？要学习的参数更少。

如果有人比我有更深入的知识，可以解释这些偏见在深度网络中的重要性（如果有的话），我将不胜感激。

这里是完整的代码和实验结果bias-VS-no_bias实验

batch_size = 16
patch_size = 5
depth = 16
num_hidden = 64

graph = tf.Graph()

with graph.as_default():

  # Input data.
  tf_train_dataset = tf.placeholder(
    tf.float32, shape=(batch_size, image_size, image_size, num_channels))
  tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))
  tf_valid_dataset = tf.constant(valid_dataset)
  tf_test_dataset = tf.constant(test_dataset)

  # Variables.
  layer1_weights = tf.Variable(tf.truncated_normal(
      [patch_size, patch_size, num_channels, depth], stddev=0.1))
  layer1_biases = tf.Variable(tf.zeros([depth])) …

我使用MATLAB神经网络工具箱训练神经网络,特别是使用命令nprtool,该命令提供了一个简单的GUI来使用工具箱特征,并导出net包含有关生成的NN的信息的对象.

通过这种方式,我创建了一个可以用作分类器的工作神经网络,并且代表它的图表如下:

第一个隐藏层有200个输入,20个神经元,最后一层有2个神经元提供二维输出.

我想要做的是在其他一些编程语言(C#,Java,...)中使用网络.

为了解决这个问题,我尝试在MATLAB中使用以下代码:

y1 = tansig(net.IW{1} * input + net.b{1});
Results = tansig(net.LW{2} * y1 + net.b{2});

假设这input是一个包含200个元素的单维数组,如果net.IW{1}是20x200矩阵(20个神经元,200个权重),则前面的代码将起作用.

问题是我发现它size(net.IW{1})返回了意外的值:

>> size(net.IW{1})

    ans =

    20   199

我在使用10000输入的网络时遇到了同样的问题.在这种情况下,结果不是20x10000,而是像20x9384(我不记得确切的值).

所以,问题是:我怎样才能获得每个神经元的权重？之后,有人可以解释我如何使用它们来生成相同的MATLAB输出？

在通过一个微小的2层神经网络的例子时,我注意到了我无法解释的结果.

想象一下,我们有以下数据集和相应的标签:

[0,1] -> [0]
[0,1] -> [0]
[1,0] -> [1]
[1,0] -> [1]

让我们创建一个微小的2层NN,它将学习预测两个数字序列的结果,其中每个数字可以是0或1.我们将根据上面提到的数据集训练这个NN.

    import numpy as np

    # compute sigmoid nonlinearity
    def sigmoid(x):
        output = 1 / (1 + np.exp(-x))
        return output

    # convert output of sigmoid function to its derivative
    def sigmoid_to_deriv(output):
        return output * (1 - output)

    def predict(inp, weigths):
        print inp, sigmoid(np.dot(inp, weigths))

    # input dataset
    X = np.array([ [0,1],
                   [0,1],
                   [1,0],
                   [1,0]])
    # output dataset
    Y = np.array([[0,0,1,1]]).T

    np.random.seed(1)

    # init weights …

我希望实现一个通用的神经网络,1个输入层由输入节点组成,1个输出层由输出节点组成,N个隐藏层由隐藏节点组成.节点被组织成图层,其规则是无法连接同一图层中的节点.

我大多理解偏见的概念,我的问题是:

每层应该有一个偏差值(由该层中的所有节点共享)还是应该每个节点(输入层中的节点除外)都有自己的偏置值？

我有一种感觉,它可以通过两种方式完成,并希望了解每种方法的权衡,并了解最常用的实现方式.