Cara Melaksanakan CNN dengan Deeplearning4j

1. Gambaran keseluruhan

Dalam tutorial ini, kami akan membina dan melatih model rangkaian saraf konvolusional menggunakan perpustakaan Deeplearning4j di Jawa.

Untuk maklumat lebih lanjut mengenai cara menubuhkan perpustakaan, sila rujuk panduan kami di Deeplearning4j.

2. Pengelasan Imej

2.1. Pernyataan masalah

Katakan kita mempunyai sekumpulan gambar. Setiap gambar mewakili objek kelas tertentu. Lebih-lebih lagi, objek pada gambar adalah milik satu-satunya kelas yang diketahui. Jadi, pernyataan masalahnya adalah untuk membina model yang akan dapat mengenali kelas objek pada gambar yang diberikan .

Sebagai contoh, katakan kita mempunyai sekumpulan gambar dengan sepuluh isyarat tangan. Kami membina model dan melatihnya untuk mengklasifikasikannya. Kemudian selepas latihan, kami mungkin melepasi gambar lain dan mengelaskan isyarat tangan pada mereka. Sudah tentu, isyarat yang diberikan mestilah tergolong dalam kelas yang diketahui.

2.2. Perwakilan Imej

Dalam memori komputer, gambar dapat ditunjukkan sebagai matriks nombor. Setiap nombor adalah nilai piksel, antara 0 hingga 255.

Gambar skala kelabu adalah matriks 2D. Begitu juga, gambar RGB adalah matriks 3D dengan dimensi lebar, tinggi, dan kedalaman.

Seperti yang kita lihat, gambar adalah sekumpulan nombor . Oleh itu, kita dapat membina model rangkaian berbilang lapisan untuk melatihnya mengklasifikasikan gambar.

3. Rangkaian Neural Konvolusional

Rangkaian Neural Konvolusional (CNN) adalah model rangkaian pelbagai lapisan yang mempunyai struktur tertentu. Struktur CNN boleh dibahagikan kepada dua blok: lapisan konvolusional dan lapisan bersambung sepenuhnya (atau padat) . Mari kita lihat masing-masing.

3.1. Lapisan Konvolusional

Setiap lapisan konvolusional adalah satu set matriks persegi, yang disebut kernel . Yang terpenting, kita memerlukan mereka melakukan konvolusi pada gambar input. Jumlah dan ukurannya mungkin berbeza-beza, bergantung pada set data yang diberikan. Kami kebanyakan menggunakan kernel 3 × 3 atau 5 × 5, dan jarang 7 × 7 kernel. Ukuran dan jumlah yang tepat dipilih berdasarkan percubaan dan kesilapan.

Sebagai tambahan, kami memilih secara rawak pemboleh ubah matriks kernel pada awal kereta api. Mereka adalah berat rangkaian.

Untuk melakukan konvolusi, kita dapat menggunakan kernel sebagai tingkap gelongsor. Kami akan mengalikan berat kernel dengan piksel gambar yang sesuai dan mengira jumlahnya. Kemudian kita dapat menggerakkan kernel untuk menutup potongan gambar seterusnya menggunakan langkah (bergerak ke kanan) dan padding (bergerak ke bawah). Hasilnya, kita akan mempunyai nilai yang akan digunakan dalam pengiraan lebih lanjut.

Ringkasnya, dengan lapisan ini, kita mendapat gambar yang berpusing . Beberapa pemboleh ubah mungkin kurang daripada sifar. Ini biasanya bermaksud bahawa pemboleh ubah ini tidak begitu penting daripada yang lain. Itulah sebabnya menerapkan fungsi ReLU adalah pendekatan yang baik untuk membuat lebih sedikit pengiraan lebih jauh.

3.2. Lapisan Subsampling

Lapisan subsampling (atau penyatuan) adalah lapisan jaringan, biasanya digunakan setelah lapisan konvolusional. Selepas konvolusi, kami mendapat banyak pemboleh ubah yang dikira . Walau bagaimanapun, tugas kami adalah memilih yang paling berharga di antara mereka .

Pendekatannya adalah dengan menerapkan algoritma sliding window pada gambar berpusing. Pada setiap langkah, kami akan memilih nilai maksimum pada tetingkap persegi dengan ukuran yang telah ditentukan, biasanya antara 2 × 2 dan 5 × 5 piksel. Hasilnya, kita akan mempunyai lebih sedikit parameter yang dikira. Oleh itu, ini akan mengurangkan pengiraan.

3.3. Lapisan Padat

Lapisan padat (atau bersambung sepenuhnya) adalah lapisan yang terdiri daripada pelbagai neuron. Kami memerlukan lapisan ini untuk melakukan klasifikasi. Lebih-lebih lagi, mungkin ada dua atau lebih lapisan seperti itu. Yang penting, lapisan terakhir harus mempunyai ukuran yang sama dengan bilangan kelas untuk klasifikasi.

Keluaran rangkaian adalah kebarangkalian gambar milik setiap kelas . Untuk meramalkan kebarangkalian, kami akan menggunakan fungsi pengaktifan Softmax.

3.4. Teknik Pengoptimuman

Untuk melakukan latihan, kita perlu mengoptimumkan bobot. Ingat, pada awalnya kita memilih pemboleh ubah ini secara rawak. Rangkaian saraf adalah fungsi besar . Dan, ia mempunyai banyak parameter yang tidak diketahui, berat kita.

Apabila kita menyampaikan gambar ke rangkaian, itu memberi kita jawapan . Kemudian, kita mungkin membina fungsi kerugian, yang bergantung pada jawapan ini . Dari segi pembelajaran yang diselia, kami juga mempunyai jawapan sebenar - kelas yang sebenarnya. Misi kami adalah untuk mengurangkan fungsi kehilangan ini . Sekiranya kita berjaya, maka model kita terlatih.

Untuk meminimumkan fungsi, kita harus mengemas kini bobot rangkaian . Untuk melakukan itu, kita dapat menghitung turunan fungsi kerugian berkenaan dengan setiap parameter yang tidak diketahui ini. Kemudian, kita dapat mengemas kini setiap berat badan.

Kita mungkin menaikkan atau menurunkan nilai berat badan untuk mencari minimum tempatan fungsi kehilangan kita kerana kita tahu cerunnya. Lebih-lebih lagi, proses ini berulang-ulang dan disebut Gradient Descent . Backpropagation menggunakan penurunan gradien untuk menyebarkan pembaharuan berat dari akhir hingga awal rangkaian.

Dalam tutorial ini, kami akan menggunakan algoritma pengoptimuman Stochastic Gradient Decent (SGD). Idea utamanya ialah kita memilih gambar kereta api secara rawak pada setiap langkah. Kemudian kami menggunakan backpropagation.

3.5. Sukatan Penilaian

Akhirnya, setelah melatih rangkaian, kita perlu mendapatkan maklumat tentang prestasi model kita.

Metrik yang paling banyak digunakan ialah ketepatan . Ini adalah nisbah gambar yang dikelaskan dengan betul untuk semua gambar. Sementara itu, ingatan, ketepatan, dan skor F1 adalah metrik yang sangat penting untuk klasifikasi gambar juga.

4. Penyediaan Set Data

Di bahagian ini, kami akan menyiapkan gambar. Mari gunakan set data CIFAR10 yang tersemat dalam tutorial ini. Kami akan membuat iterator untuk mengakses gambar:

public class CifarDatasetService implements IDataSetService { private CifarDataSetIterator trainIterator; private CifarDataSetIterator testIterator; public CifarDatasetService() { trainIterator = new CifarDataSetIterator(trainBatch, trainImagesNum, true); testIterator = new CifarDataSetIterator(testBatch, testImagesNum, false); } // other methods and fields declaration }

We can choose some parameters on our own. TrainBatch and testBatch are the numbers of images per train and evaluation step respectively. TrainImagesNum and testImagesNum are the numbers of images for training and testing. One epoch lasts trainImagesNum / trainBatch steps. So, having 2048 train images with a batch size = 32 will lead to 2048 / 32 = 64 steps per one epoch.

5. Convolutional Neural Network in Deeplearning4j

5.1. Building the Model

Next, let's build our CNN model from scratch. To do it, we'll use convolutional, subsampling (pooling), and fully connected (dense) layers.

MultiLayerConfiguration configuration = new NeuralNetConfiguration.Builder() .seed(1611) .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT) .learningRate(properties.getLearningRate()) .regularization(true) .updater(properties.getOptimizer()) .list() .layer(0, conv5x5()) .layer(1, pooling2x2Stride2()) .layer(2, conv3x3Stride1Padding2()) .layer(3, pooling2x2Stride1()) .layer(4, conv3x3Stride1Padding1()) .layer(5, pooling2x2Stride1()) .layer(6, dense()) .pretrain(false) .backprop(true) .setInputType(dataSetService.inputType()) .build(); network = new MultiLayerNetwork(configuration);

Here we specify the learning rate, the update algorithm, the input type of our model, and the layered architecture. We can experiment on these configurations. Thus, we can train many models with different architectures and training parameters. Furthermore, we can compare the results and choose the best model.

5.2. Training the Model

Then, we'll train the built model. This can be done in a few lines of code:

public void train() { network.init(); IntStream.range(1, epochsNum + 1).forEach(epoch -> { network.fit(dataSetService.trainIterator()); }); }

The number of epochs is the parameter that we can specify ourselves. We have a small dataset. As a result, several hundred epochs will be enough.

5.3. Evaluating the Model

Finally, we can evaluate the now-trained model. Deeplearning4j library provides an ability to do it easily:

public Evaluation evaluate() { return network.evaluate(dataSetService.testIterator()); }

Penilaian adalah objek, yang mengandungi metrik yang dikira setelah melatih model. Itu adalah skor ketepatan, ketepatan, ingat, dan F1 . Selain itu, ia mempunyai antara muka yang mudah dicetak:

==========================Scores===================== # of classes: 11 Accuracy: 0,8406 Precision: 0,7303 Recall: 0,6820 F1 Score: 0,6466 =====================================================

6. Kesimpulannya

Dalam tutorial ini, kami telah belajar mengenai seni bina model CNN, teknik pengoptimuman, dan metrik penilaian. Selanjutnya, kami telah menerapkan model menggunakan perpustakaan Deeplearning4j di Java.

Seperti biasa, kod untuk contoh ini boleh didapati di GitHub.