Primeros pasos con la red neuronal

Flujo de trabajo típico de una red neuronal

El flujo de trabajo típico de entrenamiento y uso de redes neuronales, independientemente de la biblioteca utilizada, es así:

Datos de entrenamiento

  1. Obtener los datos de entrenamiento: la variable X es la entrada y la variable Y es la salida. Lo más sencillo es aprender una puerta lógica, donde ‘X’ es un vector o dos números e ‘Y’ es un vector de un número. Por lo general, los valores de entrada y salida son flotantes, por lo que si se trata de palabras, puede asociar cada palabra a una neurona diferente. También podría usar caracteres directamente, entonces usaría menos neuronas que mantener un diccionario completo.

Arquitectura

  1. Definición de la arquitectura de la red neuronal: esto se hace especificando cómo se enlazan las neuronas entre sí y con qué algoritmo se entrenan y cambian las conexiones entre neuronas. Como ejemplo, el procesamiento de texto se realiza mediante redes neuronales recurrentes, que reciben una nueva entrada en cada paso de tiempo y donde las neuronas tienen una referencia a su valor anterior en el tiempo para fines de cálculo efectivos. Comúnmente, se utilizan capas de neuronas, generalmente se apilan unas sobre otras desde las entradas hasta las salidas. La forma en que las neuronas se conectan de una capa a otra varía mucho. Algunas arquitecturas de visión artificial utilizan redes neuronales profundas (con muchas capas especializadas apiladas).

Evaluación

  1. A continuación, la red neuronal generalmente se evalúa con datos en los que no se ha entrenado directamente. Esto consiste en presentar la parte ‘X’ de los datos a la red neuronal, luego comparar la ‘Y’ que predice con la ‘Y’ real. existen muchas métricas para evaluar la calidad del aprendizaje realizado.

Mejora

  1. Es común volver a jugar con la arquitectura de la red neuronal para mejorar su rendimiento. La red neuronal no debe ser demasiado inteligente ni demasiado tonta porque ambos casos generan problemas. En el primer caso, la red neuronal podría ser demasiado grande para los datos, memorizarlos perfectamente y podría no generalizarse a nuevos ejemplos no vistos. En el segundo caso, si la red neuronal es demasiado tonta (pequeña), tampoco podrá aprender.

Uso en el mundo real

  1. Usarlo en nuevos datos para predecir una salida. De hecho, las redes neuronales son bastante útiles, la traducción automática de texto o responder a una pregunta textual son buenos ejemplos. Una de las técnicas utilizadas para mejorar la red neuronal en esta etapa es el aprendizaje en línea, lo que significa que si la red puede obtener una retroalimentación constructiva sobre sus resultados, todavía es posible continuar con el proceso de aprendizaje. Como ejemplo, este podría ser el caso de Google Translate que pide a los usuarios comentarios sobre las traducciones.

Clase Python Neuron

import numpy as np #There is a lot of math in neurons, so use numpy to speed things up in python; in other languages, use an efficient array type for that language
import random      #Initial neuron weights should be random

class Neuron:

def __init__(self, nbr_inputs, weight_array = None):
    if (weight_array != None): #you might already have a trained neuron, and wish to recreate it by passing in a weight array h ere
        self.weight_array = weight_array
    else:                      #...but more often, you generate random, small numbers for the input weights.  DO NOT USE ALL ZEROES, or you increase the odds of getting stuck when learning
        self.weight_array = np.zeros(nbr_inputs+1)
        for el in range(nbr_inputs+1): #+1 to account for bias weight
            self.weight_array[el] = random.uniform((-2.4/nbr_inputs),(2.4/nbr_inputs))
    self.nbr_inputs = nbr_inputs

def neuron_output(self,input_array):
    input_array_with_bias = np.insert(input_array,0,-1)
    weighted_sum = np.dot(input_array_with_bias,self.weight_array)
    #Here we are using a hyperbolic tangent output; there are several output functions which could be used, with different max and min values and shapes
    self.output = 1.716 * np.tanh(0.67*weighted_sum)
    return self.output

Motor Java Encog

Encog es un motor de red neuronal Java fácil de usar

public static double XOR_INPUT[][] = { { 0.0, 0.0 }, { 1.0, 0.0 },
        { 0.0, 1.0 }, { 1.0, 1.0 } };

public static double XOR_IDEAL[][] = { { 0.0 }, { 1.0 }, { 1.0 }, { 0.0 } };

public static void main(final String args[]) {
    
    // create a neural network, without using a factory
    BasicNetwork network = new BasicNetwork();
    network.addLayer(new BasicLayer(null,true,2));
    network.addLayer(new BasicLayer(new ActivationSigmoid(),true,3));
    network.addLayer(new BasicLayer(new ActivationSigmoid(),false,1));
    network.getStructure().finalizeStructure();
    network.reset();

    // create training data
    MLDataSet trainingSet = new BasicMLDataSet(XOR_INPUT, XOR_IDEAL);
    
    // train the neural network
    final ResilientPropagation train = new ResilientPropagation(network, trainingSet);

    int epoch = 1;

    do {
        train.iteration();
        System.out.println("Epoch #" + epoch + " Error:" + train.getError());
        epoch++;
    } while(train.getError() > 0.01);
    train.finishTraining();

    // test the neural network
    System.out.println("Neural Network Results:");
    for(MLDataPair pair: trainingSet ) {
        final MLData output = network.compute(pair.getInput());
        System.out.println(pair.getInput().getData(0) + "," + pair.getInput().getData(1)
                + ", actual=" + output.getData(0) + ",ideal=" + pair.getIdeal().getData(0));
    }
    
    Encog.getInstance().shutdown();
}

Este es el equivalente ‘Hello World’ de las redes neuronales.