Introduksjon til Neuroph

1. Introduksjon

Denne artikkelen tar en titt på Neuroph - et open source-bibliotek for å skape nevrale nettverk og bruke maskinlæring.

I artikkelen ser vi på kjernekonseptene og flere eksempler på hvordan du kan sette det hele sammen.

2. Neuroph

Vi kan samhandle med Neuroph ved å bruke:

  • et GUI-basert verktøy
  • et Java-bibliotek

Begge tilnærmingene er avhengige av et underliggende klassehierarki som bygger kunstige nevrale nettverk ut av lag av nevroner.

Vi vil fokusere på den programmatiske siden, men vil referere til flere delte klasser fra Neurophs GUI-baserte tilnærming for å avklare hva vi gjør.

For mer informasjon om GUI-basert tilnærming, ta en titt på Neuroph-dokumentasjonen.

2.1. Avhengigheter

Hvis du skal bestille Neuroph, må vi legge til følgende Maven-oppføring:

 org.beykery neuroph 2.92 

Den nyeste versjonen finner du på Maven Central.

3. Nøkkelklasser og begreper

Alle de grunnleggende konseptuelle byggesteinene som brukes har tilsvarende Java-klasser.

Nevroner er koblet til Lag som deretter grupperes i NeuralNetworks. NeuralNetworks blir deretter trent ved hjelp av LearningRules og Datasett.

3.1. Neuron

De Neuron klasse har fire primære attributter:

  1. inputConnection: vektede forbindelser mellom Nevroner
  2. inputFunction: spesifiserer vekter og vektorsummer brukes på innkommende tilkoblingsdata
  3. overføringsfunksjon: spesifiserer vekter og vektorsummer brukt på utgående data

  4. produksjon: utgangsverdien som følge av anvendelsen av transferFunctions og inputFunctions til en inputConnection

Til sammen etablerer de fire primære attributtene atferden:

output = transferFunction (inputFunction (inputConnections));

3.2. Lag

Lag er egentlig grupper av Nevroner slik at hver Neuron i Lag er (vanligvis) bare forbundet med Nevroner i forrige og påfølgende Lag.

LagGi derfor informasjon mellom dem gjennom de vektede funksjonene som finnes på deres Nevroner.

Nevroner kan legges til lag:

Laglag = nytt Lag (); layer.addNeuron (n);

3.3. Nevrale nettverket

Superklassen på toppnivå Nevrale nettverket er underklassert i flere kjente typer kunstige nevrale nettverk inkludert konvolusjonelle nevrale nettverk (underklasse ConvolutionalNetwork), Hopfield nevrale nettverk (underklasse Hopfield), og flerlags perceptron nevrale nettverk (underklasse MultilayerPerceptron).

Alle NeuralNetworks er sammensatt av Lag som vanligvis er organisert i en trikotomi:

  1. input lag
  2. skjulte lag
  3. utgangslag

Hvis vi bruker konstruktøren til en underklasse av Nevrale nettverket (som for eksempel Perceptron), kan vi passere Lags, antall Neurons for hver Lag, og indeksen deres ved hjelp av denne enkle metoden:

NeuralNetwork ann = ny Perceptron (2, 4, 1);

Noen ganger vil vi gjøre dette manuelt (og det er godt å se hva som skjer under panseret). Den grunnleggende operasjonen for å legge til en Lag til en Nevrale nettverket oppnås slik:

NeuralNetwork ann = nytt NeuralNetwork (); Laglag = nytt Lag (); ann.addLayer (0, lag); ann.setInputNeurons (layer.getNeurons ()); 

Det første argumentet spesifiserer indeksen til Lag i Nevrale nettverket; det andre argumentet spesifiserer Lag seg selv. Lag manuelt lagt til skal kobles til ved hjelp av ConnectionFactory klasse:

ann.addLayer (0, inputLayer); ann.addLayer (1, hiddenLayerOne); ConnectionFactory.fullConnect (ann.getLayerAt (0), ann.getLayerAt (1));

Den første og siste Lag skal også kobles til:

ConnectionFactory.fullConnect (ann.getLayerAt (0), ann.getLayerAt (ann.getLayersCount () - 1), false); ann.setOutputNeurons (ann.getLayerAt (ann.getLayersCount () - 1) .getNeurons ());

Husk at styrken og kraften til en Nevrale nettverket er i stor grad avhengig av:

  1. antall Lag i Nevrale nettverket
  2. antall Nevroner i hver Lag (og vektede funksjoner mellom dem), og
  3. effektiviteten av treningsalgoritmene / nøyaktigheten til Datasett

3.4. Trening av vår Nevrale nettverket

NeuralNetworks er trent ved hjelp av Datasett og LearningRule klasser.

Datasett brukes til å representere og levere informasjonen som skal læres eller brukes til å trene Nevrale nettverket. Datasett er preget av sine inngangsstørrelse, outputsize, og rader (DataSetRow).

int inputSize = 2; int outputSize = 1; Datasett ds = nytt datasett (inputSize, outputSize); DataSetRow rOne = ny DataSetRow (ny dobbel [] {0, 0}, ny dobbel [] {0}); ds.addRow (rOne); DataSetRow rTwo = ny DataSetRow (ny dobbel [] {1, 1}, ny dobbel [] {0}); ds.addRow (rTwo);

LearningRule angir måten Datasett blir undervist eller trent av Nevrale nettverket. Underklasser av LearningRule inkludere BackPropagation og Overvåket læring.

NeuralNetwork ann = nytt NeuralNetwork (); // ... BackPropagation backPropagation = ny BackPropagation (); backPropagation.setMaxIterations (1000); ann.learn (ds, backPropagation);

4. Sette det hele sammen

La oss nå sette disse byggesteinene sammen til et reelt eksempel. Vi begynner med kombinere flere lag sammen til det kjente inngangslaget, skjult lag, og utgangslaget mønster eksemplifisert av de fleste nevrale nettverksarkitekturer.

4.1. Lag

Vi monterer våre Nevrale nettverket ved å kombinere fire lag. Målet vårt er å bygge en (2, 4, 4, 1) Nevrale nettverket.

La oss først definere inngangslaget vårt:

Layer inputLayer = nytt lag (); inputLayer.addNeuron (new Neuron ()); inputLayer.addNeuron (new Neuron ());

Deretter implementerer vi skjult lag ett:

Layer hiddenLayerOne = nytt lag (); hiddenLayerOne.addNeuron (new Neuron ()); hiddenLayerOne.addNeuron (new Neuron ()); hiddenLayerOne.addNeuron (new Neuron ()); hiddenLayerOne.addNeuron (new Neuron ());

Og skjult lag to:

Layer hiddenLayerTwo = nytt lag (); hiddenLayerTwo.addNeuron (new Neuron ()); hiddenLayerTwo.addNeuron (nye Neuron ()); hiddenLayerTwo.addNeuron (new Neuron ()); hiddenLayerTwo.addNeuron (new Neuron ());

Til slutt definerer vi utgangslaget vårt:

Layer outputLayer = nytt lag (); outputLayer.addNeuron (nye Neuron ()); 

4.2. Nevrale nettverket

Deretter kan vi sette dem sammen til en Nevrale nettverket:

NeuralNetwork ann = nytt NeuralNetwork (); ann.addLayer (0, inputLayer); ann.addLayer (1, hiddenLayerOne); ConnectionFactory.fullConnect (ann.getLayerAt (0), ann.getLayerAt (1)); ann.addLayer (2, hiddenLayerTwo); ConnectionFactory.fullConnect (ann.getLayerAt (1), ann.getLayerAt (2)); ann.addLayer (3, outputLayer); ConnectionFactory.fullConnect (ann.getLayerAt (2), ann.getLayerAt (3)); ConnectionFactory.fullConnect (ann.getLayerAt (0), ann.getLayerAt (ann.getLayersCount () - 1), false); ann.setInputNeurons (inputLayer.getNeurons ()); ann.setOutputNeurons (outputLayer.getNeurons ());

4.3. Opplæring

For treningsformål, la oss sette sammen en Datasett ved å spesifisere størrelsen på både inngangs- og resulterende utgangsvektor:

int inputSize = 2; int outputSize = 1; Datasett ds = nytt datasett (inputSize, outputSize);

Vi legger til en elementær rad i vår Datasett overholdelse av inngangs- og utgangsbegrensningene som er definert ovenfor - vårt mål i dette eksemplet er å lære nettverket vårt å utføre grunnleggende XOR (eksklusive eller) operasjoner:

DataSetRow rOne = ny DataSetRow (ny dobbel [] {0, 1}, ny dobbel [] {1}); ds.addRow (rOne); DataSetRow rTwo = ny DataSetRow (ny dobbel [] {1, 1}, ny dobbel [] {0}); ds.addRow (rTwo); DataSetRow rThree = ny DataSetRow (ny dobbel [] {0, 0}, ny dobbel [] {0}); ds.addRow (rThree); DataSetRow rFour = ny DataSetRow (ny dobbel [] {1, 0}, ny dobbel [] {1}); ds.addRow (rFour);

Neste, la oss trene vår Nevrale nettverket med den innebygde BackPropogation LearningRule:

BackPropagation backPropagation = ny BackPropagation (); backPropagation.setMaxIterations (1000); ann.learn (ds, backPropagation); 

4.4. Testing

Nå som vår Nevrale nettverket er trent opp, la oss teste det ut. For hvert par logiske verdier overført til vårt Datasett som en DataSetRow, kjører vi følgende type test:

ann.setInput (0, 1); ann.calculate (); dobbelt [] networkOutputOne = ann.getOutput (); 

En viktig ting å huske er at NeuralNetworks bare mat ut en verdi på det inkluderende intervallet 0 og 1. For å levere en annen verdi, må vi normalisere og denormalisere våre data.

I dette tilfellet, for logiske operasjoner, er 0 og 1 perfekt for jobben. Resultatet blir:

Testing: 1, 0 Forventet: 1.0 Resultat: 1.0 Testing: 0, 1 Forventet: 1.0 Resultat: 1.0 Testing: 1, 1 Forventet: 0.0 Resultat: 0.0 Testing: 0, 0 Forventet: 0.0 Resultat: 0.0 

Vi ser at vår Nevrale nettverket spår vellykket riktig svar!

5. Konklusjon

Vi har nettopp gjennomgått de grunnleggende konseptene og klassene som brukes av Neuroph.

Mer informasjon om dette biblioteket er tilgjengelig her, og kodeeksemplene som brukes i denne artikkelen finner du på GitHub.


$config[zx-auto] not found$config[zx-overlay] not found