python - redes - Implementación simple de red neuronal multicapa

redes neuronales ejemplos

Question

Hace algún tiempo comencé mi aventura con el aprendizaje automático (durante los últimos 2 años de mis estudios). He leído muchos libros y he escrito mucho código con algoritmos de aprendizaje automático EXCEPTO redes neuronales, que estaban fuera de mi alcance. Estoy muy interesado en este tema, pero tengo un gran problema: todos los libros que he leído tienen dos problemas principales:

1. Contiene tonos de ecuaciones matemáticas. Después de la conferencia, estoy bastante familiarizado con ellos y, a mano, en el papel puedo hacer los cálculos.
2. Contiene grandes ejemplos incrustados en un contexto complicado (por ejemplo, investigando las tasas de ventas en la tienda de internet) y para entrar en la implementación de redes neuronales, tengo que escribir mucho código para reproducir el contexto. Lo que falta: implementación simple SIMPLE sin mucho contexto y ecuaciones.

¿Podría aconsejarme, por favor, dónde puedo encontrar la implementación SIMPLE de la percepción de múltiples capas (red neuronal)? No necesito conocimientos teóricos, y tampoco quiero ejemplos contextuales. Prefiero algunos lenguajes de scripts para ahorrar tiempo y esfuerzo: el 99% de mis trabajos anteriores se realizaron en Python.

Aquí está la lista de libros que he leído antes (y no encontré lo que quería):

1. Aprendizaje automático en acción
2. Programación de inteligencia colectiva
3. Aprendizaje automático: una perspectiva algorítmica
4. Introducción a las redes neuronales en Java
5. Introducción a las redes neuronales en C #

Answer 1

Una implementación simple

Aquí hay una implementación legible usando clases en Python . Esta implementación intercambia eficiencia por comprensibilidad:

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

Una implementación más eficiente (con aprendizaje)

Si está buscando un ejemplo más eficiente de una red neuronal con aprendizaje (backpropagation), eche un vistazo a mi red neuronal Github repositorio aquí .

Answer 2

¿Has probado PyBrain ? Parece muy bien documented .

Answer 3

Aquí hay un ejemplo de cómo puede implementar una red neuronal feedforward usando numpy. Primero importa numpy y especifica las dimensiones de tus entradas y tus objetivos.

import numpy as np

input_dim = 1000
target_dim = 10

Vamos a construir la estructura de la red ahora. Como se sugiere en el gran "Reconocimiento de Patrones y Aprendizaje Automático" de Bishop, usted puede simplemente considerar la última fila de sus matrices numpy como ponderaciones de sesgo y la última columna de sus activaciones como neuronas de diagonal. Las dimensiones de entrada / salida de la matriz de peso primero / último deben ser 1 mayor, entonces.

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)

Si sus entradas se almacenan en una matriz nude 2d, donde cada fila corresponde a una muestra y las columnas corresponden a los atributos de sus muestras, puede propagarse a través de la red de esta manera: (asumiendo la función logística sigmoide como función de activación)

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

El último elemento de las activations será la salida de su red, pero tenga cuidado, debe omitir la columna adicional para los sesgos, de modo que su salida será activations[-1][:,:-1] .

Para entrenar una red, debe implementar la retropropagación, que requiere algunas líneas adicionales de código. Necesitas hacer un ciclo desde el último elemento de activations hasta el primero, básicamente. Asegúrese de establecer la columna de polarización en la señal de error a cero para cada capa antes de cada paso de retropropagación.

Answer 4

Hmm esto es complicado. Tuve el mismo problema antes y no pude encontrar nada entre una explicación buena pero pesadamente cargada de matemáticas y las implementaciones listas para usar.

El problema con las implementaciones listas para usar , como PyBrain, es que ocultan los detalles, por lo que las personas interesadas en aprender a implementar las RNA necesitan algo más. Leer el código de tales soluciones también puede ser un desafío porque a menudo usan la heurística para mejorar el rendimiento y eso hace que el código sea más difícil de seguir para un principiante.

Sin embargo, hay algunos recursos que podrías usar:

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 5

Here hay un algoritmo backprop en python nativo.