neural-networkAan de slag met neuraal netwerk


Opmerkingen

Neurale netwerken op technisch gebied zijn nuttig voor statistische regressie, gegevensclassificatie, productcompositie, computervisie, begrip en synthese van natuurlijke talen, spraak naar tekst, tekst naar spraak en vele andere complexe taken. Neurale netwerken worden gebruikt in machine learning en in deep learning, ze zijn gerelateerd aan kunstmatige intelligentie.

Een neuraal netwerk leert bijvoorbeeld, het is bedoeld om getraind te worden met data in, data uit, om later de output te kunnen voorspellen die een input krijgt die vergelijkbaar is met waar het op getraind was.

Er bestaat veel framework voor programmeren, trainen en gebruiken van kunstmatig neuraal netwerk. Hier zijn enkele van de meest bekende machine-learning frameworks:

  • Tensorflow
  • Caffe
  • Keras
  • Theano
  • Fakkel
  • DL4J

Java Encog-engine

Encog is een eenvoudig te gebruiken neurale netwerk-engine van Java

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();
}
 

Dit is het 'Hello World'-equivalent van neurale netwerken.

Neuron-klasse Python

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
 

Typische workflow van een neuraal netwerk

De typische workflow van training en gebruik van neurale netwerken, ongeacht de gebruikte bibliotheek, gaat als volgt:

Trainingsdata

  1. De trainingsgegevens ophalen: de X variabele is de invoer en de Y variabele is de uitvoer. Het eenvoudigste is om een logische poort te leren, waarbij X een vector of twee getallen is en Y een vector van een getal is. Meestal zijn de invoer- en uitvoerwaarden floats, dus als het woorden zijn, kunt u elk woord aan een ander neuron koppelen. Je zou ook rechtstreeks karakters kunnen gebruiken, dan zou het minder neuronen gebruiken dan om een heel woordenboek bij te houden.

architectuur

  1. Het definiëren van de architectuur van het neurale netwerk: dit wordt gedaan door te specificeren hoe de neuronen met elkaar zijn verbonden en met welk algoritme de verbindingen tussen neuronen worden getraind en gewijzigd. Als een voorbeeld wordt de verwerking van tekst gedaan met behulp van terugkerende neurale netwerken, die bij elke tijdstap een nieuwe input ontvangen en waarbij neuronen een verwijzing naar hun eerdere waarde in de tijd hebben voor effectieve berekeningsdoeleinden. Gewoonlijk worden lagen van neuronen gebruikt, deze worden meestal over elkaar heen gestapeld van de ingangen naar de uitgangen. De manier waarop neuronen van de ene laag met de andere zijn verbonden, varieert enorm. Sommige computer vision-architecturen gebruiken diepe neurale netwerken (met veel gespecialiseerde lagen gestapeld).

evaluatie

  1. Vervolgens wordt het neurale netwerk meestal geëvalueerd op gegevens waarop het niet direct is getraind. Dit bestaat uit het presenteren van het X deel van de gegevens aan het neurale netwerk en vervolgens het vergelijken van de Y het voorspelt met de echte Y er bestaan veel statistieken om de kwaliteit van het uitgevoerde leren te beoordelen.

Verbetering

  1. Het is gebruikelijk om weer met de architectuur van het neurale netwerk te spelen om de prestaties te verbeteren. Het neurale netwerk moet niet te intelligent en niet te dom zijn omdat beide gevallen problemen opleveren. In het eerste geval is het neurale netwerk mogelijk te groot voor de gegevens, waardoor het perfect wordt onthouden, en kan het mislukken om te generaliseren naar nieuwe ongeziene voorbeelden. In het tweede geval, als het neurale netwerk te dom (klein) is, zal het ook niet leren.

Real-World gebruik

  1. Gebruik het op nieuwe gegevens om een uitvoer te voorspellen. Neurale netwerken zijn inderdaad heel nuttig, automatische tekstvertaling of het beantwoorden van een tekstvraag zijn goede voorbeelden. Een van de technieken die in dit stadium worden gebruikt om het neurale netwerk te verbeteren, is online leren, wat betekent dat als het netwerk een constructieve feedback op zijn output kan krijgen, het nog steeds mogelijk is om het leerproces voort te zetten. Dit kan bijvoorbeeld het geval zijn bij Google Translate dat gebruikers feedback vraagt over vertalingen.