Pengenalan Neuroph

1. Pengenalan

Artikel ini melihat Neuroph - perpustakaan sumber terbuka untuk membuat rangkaian neural dan memanfaatkan pembelajaran mesin.

Dalam artikel ini, kita melihat konsep inti dan beberapa contoh bagaimana menyatukannya.

2. Neurof

Kami boleh berinteraksi dengan Neuroph menggunakan:

  • alat berasaskan GUI
  • perpustakaan Java

Kedua-dua pendekatan tersebut bergantung pada hierarki kelas asas yang membina rangkaian saraf tiruan dari lapisan neuron .

Kami akan memfokuskan diri pada sisi program tetapi akan merujuk kepada beberapa kelas yang dikongsi dari pendekatan berasaskan GUI Neuroph untuk membantu menjelaskan apa yang kami lakukan.

Untuk lebih lanjut mengenai pendekatan berasaskan GUI, lihat dokumentasi Neuroph.

2.1. Kebergantungan

Sekiranya memesan untuk menggunakan Neuroph, kita perlu menambahkan entri Maven berikut:

 org.beykery neuroph 2.92 

Versi terbaru boleh didapati di Maven Central.

3. Kelas dan Konsep Utama

Semua blok asas konsep yang digunakan mempunyai kelas Java yang sesuai.

Neuron disambungkan ke Lapisan yang kemudian dikelompokkan ke dalam NeuralNetworks . NeuralNetworks kemudiannya dilatih menggunakan LearningRules dan Set Data .

3.1. Neuron

The Neuron kelas mempunyai empat ciri-ciri utama:

  1. inputConnection: hubungan berwajaran antara Neuron
  2. inputFungsi: menentukan berat dan jumlah vektor yang digunakan untuk data sambungan masuk
  3. transferFungsi: menentukan berat dan jumlah vektor yang digunakan untuk data keluar

  4. output: nilai output yang dihasilkan dari penerapan transferFunctions dan inputFunctions ke inputConnection

Bersama-sama keempat-empat sifat utama membentuk tingkah laku:

output = transferFunction(inputFunction(inputConnections));

3.2. Lapisan

Lapisan pada dasarnya adalah pengelompokan Neuron sehingga setiap Neuro n dalam Lapisan (biasanya) hanya dihubungkan dengan Neuron pada Lapisan sebelumnya dan berikutnya.

Oleh itu, lapisan memberikan maklumat di antara mereka melalui fungsi berwajaran yang ada pada Neuron mereka .

Neuron boleh ditambahkan ke lapisan:

Layer layer = new Layer(); layer.addNeuron(n);

3.3. Rangkaian neural

NeuralNetwork superclass tingkat atas diklasifikasikan ke dalam beberapa jenis rangkaian neural tiruan yang biasa termasuk rangkaian neural konvolusional (subclass ConvolutionalNetwork ), rangkaian saraf Hopfield (subclass Hopfield ), dan rangkaian neural perceptron multilayer (subclass MultilayerPerceptron ).

Semua NeuralNetworks terdiri daripada Lapisan yang biasanya disusun menjadi trikotomi:

  1. lapisan input
  2. lapisan tersembunyi
  3. lapisan output

Sekiranya kita menggunakan konstruktor subkelas NeuralNetwork (seperti Perceptron ), kita dapat melewati Layer s, jumlah Neuron untuk setiap Layer , dan indeksnya menggunakan kaedah mudah ini:

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

Kadang kala kita mahu melakukannya secara manual (dan bagus untuk melihat apa yang berlaku di bawah tudung). Operasi asas untuk menambahkan Layer ke NeuralNetwork dicapai seperti ini:

NeuralNetwork ann = new NeuralNetwork(); Layer layer = new Layer(); ann.addLayer(0, layer); ann.setInputNeurons(layer.getNeurons()); 

Argumen pertama menentukan indeks Lapisan dalam NeuralNetwork ; hujah kedua menentukan Lapisan itu sendiri. Lapisan yang ditambahkan secara manual harus disambungkan menggunakan kelas ConnectionFactory :

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

Lapisan pertama dan terakhir juga harus disambungkan:

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

Ingat bahawa kekuatan dan kekuatan NeuralNetwork sangat bergantung pada:

  1. bilangan Lapisan di NeuralNetwork
  2. bilangan Neuron di setiap Lapisan (dan fungsi berwajaran di antara mereka), dan
  3. keberkesanan algoritma latihan / ketepatan DataSet

3.4. Melatih NeuralNetwork Kami

NeuralNetworks dilatih menggunakan kelas DataSet dan LearningRule .

DataSet digunakan untuk mewakili dan memberikan maklumat yang akan dipelajari atau digunakan untuk melatih NeuralNetwork . Kumpulan Data dicirikan oleh ukuran input, ukuran output, dan baris (DataSetRow).

int inputSize = 2; int outputSize = 1; DataSet ds = new DataSet(inputSize, outputSize); DataSetRow rOne = new DataSetRow(new double[] {0, 0}, new double[] {0}); ds.addRow(rOne); DataSetRow rTwo = new DataSetRow(new double[] {1, 1}, new double[] {0}); ds.addRow(rTwo);

LearningRule menentukan cara DataSet diajar atau dilatih oleh NeuralNetwork . Subkelas LearningRule merangkumi BackPropagation dan SupervisionLearning .

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

4. Mengumpulkan Semuanya

Now let's put those building blocks together into a real example. We're going to start by combining several layers together into the familiar input layer, hidden layer, and output layer pattern exemplified by most neural network architectures.

4.1. Layers

We'll assemble our NeuralNetwork by combining four layers. Our goal is to build a (2, 4, 4, 1) NeuralNetwork.

Let's first define our input layer:

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

Next, we implement hidden layer one:

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

And hidden layer two:

Layer hiddenLayerTwo = new Layer(); hiddenLayerTwo.addNeuron(new Neuron()); hiddenLayerTwo.addNeuron(new Neuron()); hiddenLayerTwo.addNeuron(new Neuron()); hiddenLayerTwo.addNeuron(new Neuron());

Finally, we define our output layer:

Layer outputLayer = new Layer(); outputLayer.addNeuron(new Neuron()); 

4.2. NeuralNetwork

Next, we can put them together into a NeuralNetwork:

NeuralNetwork ann = new 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. Training

For training purposes, let's put together a DataSet by specifying the size of both the input and resulting output vector:

int inputSize = 2; int outputSize = 1; DataSet ds = new DataSet(inputSize, outputSize);

We add an elementary row to our DataSet adhering to the input and output constraints defined above – our goal in this example is to teach our network to do basic XOR (exclusive or) operations:

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

Next, let's train our NeuralNetwork with the built in BackPropogation LearningRule:

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

4.4. Testing

Now that our NeuralNetwork is trained up let's test it out. For each pair of logical values passed into our DataSet as a DataSetRow, we run the following kind of test:

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

An important thing to remember is that NeuralNetworks only output a value on the inclusive interval of 0 and 1. To output some other value, we must normalize and denormalize our data.

In this case, for logical operations, 0 and 1 are perfect for the job. The output will be:

Testing: 1, 0 Expected: 1.0 Result: 1.0 Testing: 0, 1 Expected: 1.0 Result: 1.0 Testing: 1, 1 Expected: 0.0 Result: 0.0 Testing: 0, 0 Expected: 0.0 Result: 0.0 

We see that our NeuralNetwork successfully predicts the right answer!

5. Conclusion

We've just reviewed the basic concepts and classes used by Neuroph.

Further information on this library is available here, and the code examples used in this article can be found over on GitHub.