Regresi Logistik di Jawa

1. Perkenalan

Regresi logistik adalah instrumen penting dalam kotak alat praktisi pembelajaran mesin (ML).

Dalam tutorial ini, kita akan menjelajahi ide utama di balik regresi logistik .

Pertama, mari kita mulai dengan ikhtisar singkat tentang paradigma dan algoritme ML.

2. Ikhtisar

ML memungkinkan kita menyelesaikan masalah yang dapat kita rumuskan dengan istilah yang ramah manusia. Namun, fakta ini mungkin merupakan tantangan bagi kami para pengembang perangkat lunak. Kami telah membiasakan diri untuk mengatasi masalah yang dapat kami rumuskan dengan istilah yang ramah komputer. Misalnya, sebagai manusia, kita dapat dengan mudah mendeteksi objek pada foto atau menentukan mood sebuah frase. Bagaimana kita bisa merumuskan masalah seperti itu untuk komputer?

Untuk mencari solusinya, di ML ada tahapan khusus yang disebut training . Selama tahap ini, kami memasukkan data masukan ke algoritme kami sehingga algoritme mencoba menghasilkan kumpulan parameter yang optimal (yang disebut bobot). Semakin banyak data masukan yang kami berikan ke algoritme, semakin tepat prediksi yang kami harapkan darinya.

Pelatihan adalah bagian dari alur kerja ML yang berulang:

Kami mulai dengan memperoleh data. Seringkali, data berasal dari sumber yang berbeda. Oleh karena itu, kami harus membuatnya dalam format yang sama. Kita juga harus mengontrol bahwa kumpulan data cukup mewakili domain studi. Jika model tersebut belum pernah dilatih tentang apel merah, ia hampir tidak dapat memprediksinya.

Selanjutnya, kita harus membuat model yang akan menggunakan data dan dapat membuat prediksi. Di ML, tidak ada model yang ditentukan sebelumnya yang berfungsi dengan baik di semua situasi.

Saat menelusuri model yang benar, mungkin dengan mudah terjadi kami membuat model, melatihnya, melihat prediksinya, dan membuang model karena kami tidak puas dengan prediksi yang dibuatnya. Dalam kasus ini, kita harus mundur dan membangun model lain dan mengulangi prosesnya lagi.

3. Paradigma ML

Dalam ML, berdasarkan jenis data input yang kami miliki, kami dapat memilih tiga paradigma utama:

  • pembelajaran yang diawasi (klasifikasi gambar, pengenalan objek, analisis sentimen)
  • pembelajaran tanpa pengawasan (deteksi anomali)
  • pembelajaran penguatan (strategi permainan)

Kasus yang akan kami jelaskan dalam tutorial ini termasuk dalam supervised learning.

4. Kotak Alat ML

Di ML, ada sekumpulan alat yang bisa kita terapkan saat membangun model. Sebutkan beberapa di antaranya:

  • Regresi linier
  • Regresi logistik
  • Jaringan saraf
  • Mendukung Mesin Vektor
  • k-Tetangga Terdekat

Kami dapat menggabungkan beberapa alat saat membangun model yang memiliki prediktivitas tinggi. Faktanya, untuk tutorial ini, model kita akan menggunakan regresi logistik dan jaringan neural.

5. Perpustakaan ML

Meskipun Java bukan bahasa yang paling populer untuk membuat prototipe model ML,memiliki reputasi sebagai alat yang andal untuk membuat perangkat lunak yang kuat di banyak area termasuk ML. Oleh karena itu, kami mungkin menemukan pustaka ML yang ditulis di Java.

Dalam konteks ini, kami dapat menyebutkan library standar de-facto Tensorflow yang juga memiliki versi Java. Hal lain yang layak disebutkan adalah pustaka pembelajaran mendalam yang disebut Deeplearning4j. Ini adalah alat yang sangat kuat dan kami akan menggunakannya dalam tutorial ini juga.

6. Regresi Logistik pada Pengenalan Digit

Ide utama dari regresi logistik adalah untuk membangun model yang memprediksi label data masukan seakurat mungkin.

Kami melatih model hingga yang disebut fungsi kerugian atau fungsi tujuan mencapai nilai minimal. Fungsi kerugian bergantung pada prediksi model aktual dan prediksi yang diharapkan (label data input). Tujuan kami adalah untuk meminimalkan divergensi prediksi model aktual dan yang diharapkan.

Jika kami tidak puas dengan nilai minimum tersebut, kami harus membuat model lain dan melakukan pelatihan lagi.

Untuk melihat regresi logistik beraksi, kami mengilustrasikannya pada pengenalan angka tulisan tangan. Masalah ini sudah menjadi masalah klasik. Library Deeplearning4j memiliki serangkaian contoh realistis yang menunjukkan cara menggunakan API-nya. Bagian terkait kode dari tutorial ini sangat didasarkan pada MNIST Classifier .

6.1. Memasukan data

Sebagai data masukan, kami menggunakan database MNIST yang terkenal dengan digit tulisan tangan. Sebagai data masukan, kami memiliki gambar skala abu-abu 28 × 28 piksel. Setiap gambar memiliki label alami yang merupakan digit yang diwakili oleh gambar tersebut:

Untuk memperkirakan efisiensi model yang akan kami buat, kami membagi data masukan menjadi set pelatihan dan pengujian:

DataSetIterator train = new RecordReaderDataSetIterator(...); DataSetIterator test = new RecordReaderDataSetIterator(...);

Setelah gambar masukan diberi label dan dibagi menjadi dua set, tahap "elaborasi data" selesai dan kita dapat melanjutkan ke "pembuatan model".

6.2. Pembuatan Model

Seperti yang telah kami sebutkan, tidak ada model yang bekerja dengan baik di setiap situasi. Namun demikian, setelah bertahun-tahun penelitian di ML, para ilmuwan telah menemukan model yang bekerja sangat baik dalam mengenali angka tulisan tangan. Di sini, kami menggunakan apa yang disebut model LeNet-5.

LeNet-5 adalah jaringan saraf yang terdiri dari serangkaian lapisan yang mengubah gambar 28 × 28 piksel menjadi vektor sepuluh dimensi:

Vektor keluaran sepuluh dimensi berisi kemungkinan bahwa label gambar masukan adalah 0, atau 1, atau 2, dan seterusnya.

Misalnya, jika vektor keluaran memiliki bentuk berikut:

{0.1, 0.0, 0.3, 0.2, 0.1, 0.1, 0.0, 0.1, 0.1, 0.0}

itu berarti probabilitas gambar masukan menjadi nol adalah 0,1, menjadi satu adalah 0, menjadi dua adalah 0,3, dll. Kita melihat bahwa probabilitas maksimal (0,3) sesuai dengan label 3.

Let's dive into details of model building. We omit Java-specific details and concentrate on ML concepts.

We set up the model by creating a MultiLayerNetwork object:

MultiLayerNetwork model = new MultiLayerNetwork(config);

In its constructor, we should pass a MultiLayerConfiguration object. This is the very object that describes the geometry of the neural network. In order to define the network geometry, we should define every layer.

Let's show how we do this with the first and the second one:

ConvolutionLayer layer1 = new ConvolutionLayer .Builder(5, 5).nIn(channels) .stride(1, 1) .nOut(20) .activation(Activation.IDENTITY) .build(); SubsamplingLayer layer2 = new SubsamplingLayer .Builder(SubsamplingLayer.PoolingType.MAX) .kernelSize(2, 2) .stride(2, 2) .build();

We see that layers' definitions contain a considerable amount of ad-hoc parameters which impact significantly on the whole network performance. This is exactly where our ability to find a good model in the landscape of all ones becomes crucial.

Now, we are ready to construct the MultiLayerConfiguration object:

MultiLayerConfiguration config = new NeuralNetConfiguration.Builder() // preparation steps .list() .layer(layer1) .layer(layer2) // other layers and final steps .build();

that we pass to the MultiLayerNetwork constructor.

6.3. Training

The model that we constructed contains 431080 parameters or weights. We're not going to give here the exact calculation of this number, but we should be aware that just the first layer has more than 24x24x20 = 11520 weights.

The training stage is as simple as:

model.fit(train); 

Initially, the 431080 parameters have some random values, but after the training, they acquire some values that determine the model performance. We may evaluate the model's predictiveness:

Evaluation eval = model.evaluate(test); logger.info(eval.stats());

The LeNet-5 model achieves quite a high accuracy of almost 99% even in just a single training iteration (epoch). If we want to achieve higher accuracy, we should make more iterations using a plain for-loop:

for (int i = 0; i < epochs; i++) { model.fit(train); train.reset(); test.reset(); } 

6.4. Prediction

Now, as we trained the model and we are happy with its predictions on the test data, we can try the model on some absolutely new input. To this end, let's create a new class MnistPrediction in which we'll load an image from a file that we select from the filesystem:

INDArray image = new NativeImageLoader(height, width, channels).asMatrix(file); new ImagePreProcessingScaler(0, 1).transform(image);

The variable image contains our picture being reduced to 28×28 grayscale one. We can feed it to our model:

INDArray output = model.output(image);

The variable output will contain the probabilities of the image to be zero, one, two, etc.

Sekarang mari bermain sedikit dan menulis angka 2, mendigitalkan gambar ini dan memberinya makan model. Kami mungkin mendapatkan sesuatu seperti ini:

Seperti yang kita lihat, komponen dengan nilai maksimal 0,99 memiliki indeks dua. Artinya, model tersebut telah mengenali dengan benar digit tulisan tangan kita.

7. Kesimpulan

Dalam tutorial ini, kami menjelaskan konsep umum machine learning. Kami mengilustrasikan konsep ini pada contoh regresi logistik yang kami terapkan pada pengenalan digit tulisan tangan.

Seperti biasa, kami mungkin menemukan cuplikan kode yang sesuai di repositori GitHub kami.