Introduktion til Neuroph

1. Introduktion

Denne artikel ser på Neuroph - et open source-bibliotek til oprettelse af neurale netværk og anvendelse af maskinindlæring.

I artiklen ser vi på kernebegreberne og flere eksempler på, hvordan man sætter det hele sammen.

2. Neuroph

Vi kan interagere med Neuroph ved hjælp af:

  • et GUI-baseret værktøj
  • et Java-bibliotek

Begge tilgange er afhængige af et underliggende klassehierarki, der bygger kunstige neurale netværk ud af lag af neuroner.

Vi fokuserer på den programmatiske side, men henviser til flere delte klasser fra Neurophs GUI-baserede tilgang for at hjælpe med at afklare, hvad vi laver.

For mere information om den GUI-baserede tilgang, se Neuroph-dokumentationen.

2.1. Afhængigheder

Hvis vi skal bestille Neuroph, skal vi tilføje følgende Maven-post:

 org.beykery neuroph 2.92 

Den seneste version kan findes på Maven Central.

3. Nøgleklasser og begreber

Alle de anvendte grundlæggende konceptuelle byggesten har tilsvarende Java-klasser.

Neuroner er forbundet til Lag som derefter grupperes i NeuralNetworks. NeuralNetworks efterfølgende trænes ved hjælp af LearningRules og Datasæt.

3.1. Neuron

Det Neuron klasse har fire primære attributter:

  1. inputConnection: vægtede forbindelser mellem Neuroner
  2. inputFunktion: specificerer vægte og vektor summer anvendt på indgående forbindelsesdata
  3. transferFunction: specificerer vægte og vektor summer anvendt på udgående data

  4. produktion: outputværdien som følge af anvendelsen af transferFunctions og inputFunktioner til en inputConnection

Tilsammen etablerer disse fire primære attributter adfærd:

output = transferFunction (inputFunction (inputConnections));

3.2. Lag

Lag er i det væsentlige grupperinger af Neuroner sådan at hver Neuron i Lag er (normalt) kun forbundet med Neuroner i det foregående og efterfølgende Lag.

Lagsend derfor information mellem dem gennem de vægtede funktioner, der findes på deres Neuroner.

Neuroner kan føjes til lag:

Laglag = nyt lag (); layer.addNeuron (n);

3.3. Neuralnetværk

Superklassen på øverste niveau Neuralnetværk er underklasseret i adskillige velkendte slags kunstige neurale netværk inklusive nedbrydningsneurale netværk (underklasse ConvolutionalNetwork), Hopfield neurale netværk (underklasse Hopfield), og multilayer perceptron neurale netværk (underklasse MultilayerPerceptron).

Alle NeuralNetworks er sammensat af Lag som normalt er organiseret i en trikotomi:

  1. input lag
  2. skjulte lag
  3. output lag

Hvis vi bruger konstruktøren af ​​en underklasse af Neuralnetværk (såsom Perceptron), kan vi passere Lags, antallet af Neurons for hver Lagog deres indeks ved hjælp af denne enkle metode:

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

Nogle gange vil vi gøre dette manuelt (og det er godt at se, hvad der foregår under emhætten). Den grundlæggende handling for at tilføje en Lag til en Neuralnetværk opnås sådan:

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

Det første argument specificerer indekset for Lag i Neuralnetværk; det andet argument specificerer Lag sig selv. Lag tilføjet manuelt skal forbindes ved hjælp af ConnectionFactory klasse:

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

Den første og sidste Lag skal også tilsluttes:

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

Husk, at styrken og kraften i en Neuralnetværk er stort set afhængige af:

  1. antallet af Lag i Neuralnetværk
  2. antallet af Neuroner i hver Lag (og vægtede funktioner mellem dem), og
  3. effektiviteten af ​​træningsalgoritmerne / nøjagtigheden af Datasæt

3.4. Uddannelse af vores Neuralnetværk

NeuralNetworks trænes ved hjælp af Datasæt og LearningRule klasser.

Datasæt bruges til at repræsentere og levere de oplysninger, der skal læres eller bruges til at træne Neuralnetværk. Datasæt er kendetegnet ved deres input størrelse, output størrelse, og rækker (DataSetRow).

int inputSize = 2; int outputSize = 1; Datasæt ds = nyt datasæt (inputSize, outputSize); DataSetRow rOne = ny DataSetRow (ny dobbelt [] {0, 0}, ny dobbelt [] {0}); ds.addRow (rOne); DataSetRow rTwo = ny DataSetRow (ny dobbelt [] {1, 1}, ny dobbelt [] {0}); ds.addRow (rTwo);

LearningRule angiver, hvordan Datasæt undervises eller trænes af Neuralnetværk. Underklasser af LearningRule omfatte BackPropagation og Overvåget læring.

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

4. Sætte det hele sammen

Lad os nu sætte disse byggesten sammen til et rigtigt eksempel. Vi starter med kombinerer flere lag sammen til det velkendte input lag, skjult lagog outputlag mønster eksemplificeret af de fleste neurale netværksarkitekturer.

4.1. Lag

Vi samler vores Neuralnetværk ved at kombinere fire lag. Vores mål er at bygge en (2, 4, 4, 1) Neuralnetværk.

Lad os først definere vores inputlag:

Lag inputLayer = nyt lag (); inputLayer.addNeuron (ny Neuron ()); inputLayer.addNeuron (ny Neuron ());

Dernæst implementerer vi skjult lag et:

Lag HiddenLayerOne = nyt lag (); hiddenLayerOne.addNeuron (ny Neuron ()); hiddenLayerOne.addNeuron (ny Neuron ()); hiddenLayerOne.addNeuron (ny Neuron ()); hiddenLayerOne.addNeuron (ny Neuron ());

Og skjult lag to:

Lag hiddenLayerTwo = nyt lag (); hiddenLayerTwo.addNeuron (ny Neuron ()); hiddenLayerTwo.addNeuron (ny Neuron ()); hiddenLayerTwo.addNeuron (ny Neuron ()); hiddenLayerTwo.addNeuron (ny Neuron ());

Endelig definerer vi vores outputlag:

Lag outputLayer = nyt lag (); outputLayer.addNeuron (ny Neuron ()); 

4.2. Neuralnetværk

Dernæst kan vi sætte dem sammen i en Neuralnetværk:

NeuralNetwork ann = nyt 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), falsk); ann.setInputNeurons (inputLayer.getNeurons ()); ann.setOutputNeurons (outputLayer.getNeurons ());

4.3. Uddannelse

Til træningsformål, lad os sammensætte en Datasæt ved at specificere størrelsen på både input og resulterende outputvektor:

int inputSize = 2; int outputSize = 1; Datasæt ds = nyt datasæt (inputSize, outputSize);

Vi tilføjer en elementær række til vores Datasæt overholdelse af de indgangs- og outputbegrænsninger, der er defineret ovenfor - vores mål i dette eksempel er at lære vores netværk at udføre grundlæggende XOR-operationer (eksklusiv eller):

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

Lad os derefter træne vores Neuralnetværk med den indbyggede BackPropogation LearningRule:

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

4.4. Testning

Nu hvor vores Neuralnetværk er trænet op, lad os teste det. For hvert par logiske værdier, der overføres til vores Datasæt som en DataSetRow, kører vi følgende test:

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

En vigtig ting at huske er, at NeuralNetworks output kun en værdi i det inklusive interval på 0 og 1. For at afgive en anden værdi skal vi normalisere og denormalisere vores data.

I dette tilfælde er 0 og 1 til logiske operationer perfekte til jobbet. Outputtet vil være:

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

Vi ser, at vores Neuralnetværk forudsiger med succes det rigtige svar!

5. Konklusion

Vi har lige gennemgået de grundlæggende koncepter og klasser, der bruges af Neuroph.

Yderligere information om dette bibliotek er tilgængelig her, og kodeeksemplerne, der bruges i denne artikel, kan findes på GitHub.