Ответ 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)])

Более эффективная реализация (с обучением)

Если вы ищете более эффективный пример нейронной сети с обучением (backpropagation), взгляните на мой нейронный репозиторий Github здесь.

Ответ 2

Вот пример того, как вы можете реализовать нейронную сеть с прямой связью, используя 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, где каждая строка соответствует одному образцу, а столбцы соответствуют атрибутам ваших образцов, вы можете распространяться по сети следующим образом: (предполагая, что логическая сигмоидальная функция является функцией активации)

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].

Чтобы обучить сеть, вам нужно реализовать backpropagation, которая занимает несколько дополнительных строк кода. В основном вам нужно зациклиться от последнего элемента activations до первого. Убедитесь, что столбец смещения в сигнале ошибки равен нулю для каждого слоя перед каждым шагом обратного распространения.

Ответ 3

Хм, это сложно. Раньше у меня была такая же проблема, и я не мог найти ничего между хорошим, но тяжелым математическим объяснением и готовностью использовать реализации.

Проблема с готовыми к использованию реализациями, такими как PyBrain, заключается в том, что они скрывают детали, поэтому люди, заинтересованные в обучении внедрению ANN, нуждаются в чем-то другом. Чтение кода таких решений может быть сложным, потому что они часто используют эвристику для повышения производительности, что делает код более сложным для стартера.

Однако есть несколько ресурсов, которые вы могли бы использовать:

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/

Ответ 4

Здесь - это алгоритм backprop в native python.

Ответ 5

Вы пробовали PyBrain? Это выглядит очень хорошо документально.