前一段时间我已经开始（在过去的2年，我的研究），我的机器学习的冒险。我已经阅读了大量的书籍，并写了很多的代码与机器学习算法EXCEPT神经网络，这是我的范围。我对这个话题很感兴趣，但我有一个巨大的问题：所有我看过的书有两个主要问题：

包含数学公式的色调。讲座结束后我很熟悉他们，并用手在纸上，我可以做计算。
包含嵌入在一些复杂的情况下大的实例（例如调查网上商店的销售率）和进去神经网络的实现，我必须写很多代码重现上下文。缺什么 - 一个简单的实现没有大量的背景和方程。

能否请你告诉我，在那里我能找到简单的实现多层感知（神经网络）的？我不需要理论知识和唐也想上下文嵌入式例子。我更喜欢一些脚本语言，以节省时间和精力 - 我以前的作品中99％是用Python完成。

下面是书我以前看过（而不是找到我想要的东西）名单：

机器学习在行动
集体智慧编程
机器学习：一种算法透视
简介在Java神经网络
介绍在C＃中的神经网络

Answer 1:

一个简单的实现

下面是使用类可读实现Python 。此实现交易效率可理解：

    import math
    import random

    BIAS = -1

    """
    To view the structure of the Neural Network, type
    print network_name
    """

    class Neuron:
        def __init__(self, n_inputs ):
            self.n_inputs = n_inputs
            self.set_weights( [random.uniform(0,1) for x in range(0,n_inputs+1)] ) # +1 for bias weight

        def sum(self, inputs ):
            # Does not include the bias
            return sum(val*self.weights[i] for i,val in enumerate(inputs))

        def set_weights(self, weights ):
            self.weights = weights

        def __str__(self):
            return 'Weights: %s, Bias: %s' % ( str(self.weights[:-1]),str(self.weights[-1]) )

    class NeuronLayer:
        def __init__(self, n_neurons, n_inputs):
            self.n_neurons = n_neurons
            self.neurons = [Neuron( n_inputs ) for _ in range(0,self.n_neurons)]

        def __str__(self):
            return 'Layer:\n\t'+'\n\t'.join([str(neuron) for neuron in self.neurons])+''

    class NeuralNetwork:
        def __init__(self, n_inputs, n_outputs, n_neurons_to_hl, n_hidden_layers):
            self.n_inputs = n_inputs
            self.n_outputs = n_outputs
            self.n_hidden_layers = n_hidden_layers
            self.n_neurons_to_hl = n_neurons_to_hl

            # Do not touch
            self._create_network()
            self._n_weights = None
            # end

        def _create_network(self):
            if self.n_hidden_layers>0:
                # create the first layer
                self.layers = [NeuronLayer( self.n_neurons_to_hl,self.n_inputs )]

                # create hidden layers
                self.layers += [NeuronLayer( self.n_neurons_to_hl,self.n_neurons_to_hl ) for _ in range(0,self.n_hidden_layers)]

                # hidden-to-output layer
                self.layers += [NeuronLayer( self.n_outputs,self.n_neurons_to_hl )]
            else:
                # If we don't require hidden layers
                self.layers = [NeuronLayer( self.n_outputs,self.n_inputs )]

        def get_weights(self):
            weights = []

            for layer in self.layers:
                for neuron in layer.neurons:
                    weights += neuron.weights

            return weights

        @property
        def n_weights(self):
            if not self._n_weights:
                self._n_weights = 0
                for layer in self.layers:
                    for neuron in layer.neurons:
                        self._n_weights += neuron.n_inputs+1 # +1 for bias weight
            return self._n_weights

        def set_weights(self, weights ):
            assert len(weights)==self.n_weights, "Incorrect amount of weights."

            stop = 0
            for layer in self.layers:
                for neuron in layer.neurons:
                    start, stop = stop, stop+(neuron.n_inputs+1)
                    neuron.set_weights( weights[start:stop] )
            return self

        def update(self, inputs ):
            assert len(inputs)==self.n_inputs, "Incorrect amount of inputs."

            for layer in self.layers:
                outputs = []
                for neuron in layer.neurons:
                    tot = neuron.sum(inputs) + neuron.weights[-1]*BIAS
                    outputs.append( self.sigmoid(tot) )
                inputs = outputs   
            return outputs

        def sigmoid(self, activation,response=1 ):
            # the activation function
            try:
                return 1/(1+math.e**(-activation/response))
            except OverflowError:
                return float("inf")

        def __str__(self):
            return '\n'.join([str(i+1)+' '+str(layer) for i,layer in enumerate(self.layers)])

更有效的实现（与学习）

如果您正在使用学习（反向传播）寻找一个神经网络更有效的例子，来看看我的神经网络Github上这里仓库。

Answer 2:

嗯，这是非常棘手。我收到了同样的问题，我找不到好的，但大量的数学解释加载，并准备使用实现之间的任何东西。

与准备使用实现比如PyBrain的问题是，他们隐藏的细节，让有兴趣学习如何实施人工神经网络的人都需要的东西。读这样的解决方案的代码可以是具有挑战性的太因为他们经常用启发式方法来提高性能，并且使代码更难遵循首发。

不过，也有可以使用的资源的几个：

http://msdn.microsoft.com/en-us/magazine/jj658979.aspx

http://itee.uq.edu.au/~cogs2010/cmc/chapters/BackProp/

http://www.codeproject.com/Articles/19323/Image-Recognition-with-Neural-Networks

http://freedelta.free.fr/r/php-code-samples/artificial-intelligence-neural-network-backpropagation/

Answer 3:

下面是如何使用numpy的实现前馈神经网络的例子。首先导入numpy的，并指定你的输入和你的目标尺寸。

import numpy as np

input_dim = 1000
target_dim = 10

现在，我们将建立网络结构。正如主教的伟大“模式识别与机器学习”的建议，你可以简单地考虑您的numpy的矩阵的最后一排的偏置权重和您激活作为偏置神经元的最后一列。输入/第一/最后的权重矩阵的输出尺寸需要是1时，然后。

dimensions = [input_dim+1, 500, 500, target_dim+1]

weight_matrices = []
for i in range(len(dimensions)-1):
  weight_matrix = np.ones((dimensions[i], dimensions[i]))
  weight_matrices.append(weight_matrix)

如果输入被存储在一个2D numpy的矩阵，其中每一行对应于一个采样和列对应于对样品的属性，可以通过网络这样传播：（假设逻辑S形函数作为激活函数）

def activate_network(inputs):
  activations = [] # we store the activations for each layer here
  a = np.ones((inputs.shape[0], inputs.shape[1]+1)) #add the bias to the inputs
  a[:,:-1] = inputs

  for w in weight_matrices:
    x = a.dot(w) # sum of weighted inputs
    a = 1. / (1. - np.exp(-x)) # apply logistic sigmoid activation
    a[:,-1] = 1. # bias for the next layer.
    activations.append(a)

  return activations

在最后一个元素activations将是你的网络的输出，但要小心，你需要省略了偏见的附加列，所以你的输出就会activations[-1][:,:-1]

为了训练网络，您需要实现反向传播这需要的代码的一些其他行。你需要从循环的最后一个元素activations了第一张，基本上是这样。确保在误差信号的偏置柱设置为零对每个反向传播步骤之前每一层。