Deep Learning sekarang ada di Jawa

Tidak suka Java? Ya, Anda tidak tahu cara memasaknya! Mani Sarkar mengundang kami untuk berkenalan dengan alat Valohai, yang memungkinkan dilakukannya penelitian model di Jawa.

Pendahuluan

Beberapa waktu lalu, saya menemukan layanan cloud bernama Valohai, dan saya senang dengan antarmuka penggunanya dan kesederhanaan desain dan tata letak. Saya meminta layanan dari salah satu anggota Valohai dan menerima versi demo. Sebelum itu, saya menulis pipa sederhana menggunakan GNU Parallel, JavaScript, Python dan Bash - dan yang lainnya hanya menggunakan GNU Parallel dan Bash.

Saya juga berpikir tentang menggunakan alat manajemen tugas / alur kerja yang siap digunakan seperti Jenkins X, Jenkins Pipeline, Concourse atau Airflow, tetapi karena berbagai alasan saya memutuskan untuk tidak melakukannya.

Saya perhatikan bahwa banyak contoh dan dokumentasi Valohai didasarkan pada Python dan R serta kerangka dan pustaka masing-masing. Saya memutuskan untuk tidak melewatkan kesempatan dan ingin memperbaiki kekurangan contoh dan dokumentasi.

Valohai mendorong saya untuk mengimplementasikan sesuatu menggunakan perpustakaan Java yang terkenal yang disebut DL4J - Deep Learning for Java .

Pengalaman pertama saya dengan Valohai membuat kesan yang baik pada saya setelah merasakan melalui desain, tata letak dan alur kerja. Pembuat telah memperhitungkan berbagai aspek alur kerja pengembang dan infrastruktur. Di dunia kita, proses pengembangan infrastruktur sebagian besar dikendalikan oleh tim DevOps atau SysOps, dan kita tahu nuansa dan titik sakit yang terkait dengannya.

Apa yang kita butuhkan dan bagaimana caranya?

Dalam setiap proyek pembelajaran mesin, ada dua komponen penting (dari sudut pandang tingkat tinggi) - kode yang akan bekerja dengan model, dan kode yang akan bekerja dengan infrastruktur, di mana seluruh siklus hidup proyek akan dieksekusi.

Tentu saja, akan ada langkah-langkah dan komponen yang diperlukan sebelum, selama dan sesudahnya, tetapi untuk kesederhanaan, katakanlah, kita memerlukan kode dan infrastruktur.

Kode

Untuk kode, saya memilih contoh kompleks menggunakan DL4J, ini adalah proyek MNist dengan set pelatihan 60.000 gambar dan satu set uji 10.000 gambar digit tulisan tangan. Dataset ini tersedia melalui pustaka DL4J (seperti Keras).

Sebelum Anda mulai, Anda disarankan untuk melihat kode sumber yang akan kami gunakan. Kelas Java utama disebut org.deeplearning4j.feedforward.mnist.MLPMnistSingleLayerRunner .

Infrastruktur

Kami memutuskan untuk mencoba contoh Java menggunakan Valohai sebagai infrastruktur kami untuk melakukan eksperimen (pelatihan dan evaluasi model). Valohai mengenali repositori git dan terhubung langsung ke mereka, memungkinkan kami untuk mengeksekusi kode kami terlepas dari platform atau bahasa - jadi kami akan melihat cara kerjanya. Ini juga berarti bahwa jika Anda menggunakan GitOps atau Infrastructure-As-Code, semuanya akan bekerja untuk Anda juga.

Untuk melakukan ini, kita hanya perlu akun di Valohai. Setelah membuat akun gratis, kami mendapatkan akses ke beberapa contoh berbagai konfigurasi. Untuk apa yang ingin kami lakukan, Free-Tier lebih dari cukup.

Pembelajaran yang mendalam untuk Jawa dan Valohai

Kami akan memberikan semua dependensi ke gambar Docker dan menggunakannya untuk mengkompilasi aplikasi Java kami, melatih model dan mengevaluasinya pada platform Valohai menggunakan file valohai.yaml sederhana yang terletak di folder root dari repositori proyek.

Pembelajaran Jauh untuk Java: DL4J

Bagian paling sederhana. Kami tidak perlu berbuat banyak, cukup kumpulkan toples dan muat dataset ke dalam wadah Docker. Kami memiliki gambar Docker yang dibuat sebelumnya yang berisi semua dependensi yang diperlukan untuk membuat aplikasi Java. Kami meletakkan gambar ini di Docker Hub, dan Anda dapat menemukannya dengan mencari dl4j-mnist-single-layer (kami akan menggunakan tag khusus seperti yang didefinisikan dalam file YAML). Kami memutuskan untuk menggunakan GraalVM 19.1.1 sebagai lingkungan Java build and runtime kami untuk proyek ini, dan itu dibangun ke dalam gambar Docker.

Ketika tabung uber dipanggil dari baris perintah, kami membuat kelas MLPMnistSingleLayerRunner, yang memberi tahu kami tindakan yang dimaksud, tergantung pada parameter yang diteruskan ke:

public static void main(String[] args) throws Exception { MLPMnistSingleLayerRunner mlpMnistRunner = new MLPMnistSingleLayerRunner(); JCommander.newBuilder() .addObject(mlpMnistRunner) .build() .parse(args); mlpMnistRunner.execute(); } 

Parameter yang diteruskan ke tabung uber diterima oleh kelas ini dan diproses dengan metode execute ().

Kita dapat membuat model menggunakan parameter --action train dan mengevaluasi model yang dibuat menggunakan parameter --action evaluation yang diteruskan ke aplikasi Java.

Bagian utama dari aplikasi Java yang melakukan pekerjaan ini dapat ditemukan di dua kelas Java yang disebutkan di bagian di bawah ini.

Pelatihan model

Panggil

 ./runMLPMnist.sh --action train --output-dir ${VH_OUTPUTS_DIR} or java -Djava.library.path="" \ -jar target/MLPMnist-1.0.0-bin.jar \ --action train --output-dir ${VH_OUTPUTS_DIR} 

Perintah ini menciptakan model bernama mlpmnist-single-layer.pb di folder yang ditentukan oleh parameter --output-dir yang diteruskan pada awal eksekusi. Dari sudut pandang Valohai, itu harus ditempatkan dalam $ {VH_OUTPUTS_DIR}, yang kita lakukan (lihat file valohai.yaml ).

Untuk kode sumber, lihat kelas MLPMNistSingleLayerTrain.java .

Evaluasi Model

Panggil

 ./runMLPMnist.sh --action evaluate --input-dir ${VH_INPUTS_DIR}/model or java -Djava.library.path="" \ -jar target/MLPMnist-1.0.0-bin.jar \ --action evaluate --input-dir ${VH_INPUTS_DIR}/model 

Diasumsikan bahwa model (dibuat selama fase pelatihan) dengan nama mlpmnist-single-layer.pb akan hadir dalam folder yang ditentukan dalam parameter --input-dir yang dilewati ketika aplikasi dipanggil.

Untuk kode sumber, lihat kelas MLPMNistSingleLayerEvaluate.java .

Saya harap ilustrasi singkat ini menjelaskan bagaimana aplikasi Java yang mengajarkan dan mengevaluasi suatu model bekerja.

Ini semua yang diperlukan dari kami, tetapi jangan ragu untuk bermain dengan sumber - sumber lainnya (bersama dengan README.md dan skrip bash) dan memuaskan rasa ingin tahu dan pemahaman Anda tentang bagaimana ini dilakukan!

Valohai

Valohai memungkinkan kami untuk secara bebas menautkan runtime, kode, dan dataset kami, seperti yang Anda lihat dari struktur file YAML di bawah ini. Dengan demikian, berbagai komponen dapat berkembang secara independen satu sama lain. Akibatnya, hanya komponen perakitan dan runtime yang dikemas dalam wadah Docker kami.

Pada waktu berjalan, kami mengumpulkan Uber JAR dalam wadah Docker, memuatnya ke beberapa penyimpanan internal atau eksternal, dan kemudian menggunakan langkah eksekusi lainnya untuk memuat Uber JAR dan dataset dari penyimpanan (atau tempat lain) untuk memulai pelatihan. Dengan demikian, dua langkah eksekusi terputus; misalnya, kita dapat mengkompilasi sebuah toples sekali dan menyelesaikan ratusan langkah pelatihan pada satu stoples. Karena lingkungan perakitan dan runtime tidak harus sering berubah, kita dapat menyimpannya, dan kode, kumpulan data, dan model dapat diakses secara dinamis saat runtime.

valohai.yaml
Bagian utama dari mengintegrasikan proyek Java kami dengan infrastruktur Valohai adalah untuk menentukan urutan langkah-langkah Eksekusi dalam file valohai.yaml yang terletak di root folder proyek Anda. Valohai.yaml kami terlihat seperti ini:

 --- - step: name: Build-dl4j-mnist-single-layer-java-app image: neomatrix369/dl4j-mnist-single-layer:v0.5 command: - cd ${VH_REPOSITORY_DIR} - ./buildUberJar.sh - echo "~~~ Copying the build jar file into ${VH_OUTPUTS_DIR}" - cp target/MLPMnist-1.0.0-bin.jar ${VH_OUTPUTS_DIR}/MLPMnist-1.0.0.jar - ls -lash ${VH_OUTPUTS_DIR} environment: aws-eu-west-1-g2-2xlarge - step: name: Run-dl4j-mnist-single-layer-train-model image: neomatrix369/dl4j-mnist-single-layer:v0.5 command: - echo "~~~ Unpack the MNist dataset into ${HOME} folder" - tar xvzf ${VH_INPUTS_DIR}/dataset/mlp-mnist-dataset.tgz -C ${HOME} - cd ${VH_REPOSITORY_DIR} - echo "~~~ Copying the build jar file from ${VH_INPUTS_DIR} to current location" - cp ${VH_INPUTS_DIR}/dl4j-java-app/MLPMnist-1.0.0.jar . - echo "~~~ Run the DL4J app to train model based on the the MNist dataset" - ./runMLPMnist.sh {parameters} inputs: - name: dl4j-java-app description: DL4J Java app file (jar) generated in the previous step 'Build-dl4j-mnist-single-layer-java-app' - name: dataset default: https://github.com/neomatrix369/awesome-ai-ml-dl/releases/download/mnist-dataset-v0.1/mlp-mnist-dataset.tgz description: MNist dataset needed to train the model parameters: - name: --action pass-as: '--action {v}' type: string default: train description: Action to perform ie train or evaluate - name: --output-dir pass-as: '--output-dir {v}' type: string default: /valohai/outputs/ description: Output directory where the model will be created, best to pick the Valohai output directory environment: aws-eu-west-1-g2-2xlarge - step: name: Run-dl4j-mnist-single-layer-evaluate-model image: neomatrix369/dl4j-mnist-single-layer:v0.5 command: - cd ${VH_REPOSITORY_DIR} - echo "~~~ Copying the build jar file from ${VH_INPUTS_DIR} to current location" - cp ${VH_INPUTS_DIR}/dl4j-java-app/MLPMnist-1.0.0.jar . - echo "~~~ Run the DL4J app to evaluate the trained MNist model" - ./runMLPMnist.sh {parameters} inputs: - name: dl4j-java-app description: DL4J Java app file (jar) generated in the previous step 'Build-dl4j-mnist-single-layer-java-app' - name: model description: Model file generated in the previous step 'Run-dl4j-mnist-single-layer-train-model' parameters: - name: --action pass-as: '--action {v}' type: string default: evaluate description: Action to perform ie train or evaluate - name: --input-dir pass-as: '--input-dir {v}' type: string default: /valohai/inputs/model description: Input directory where the model created by the previous step can be found created environment: aws-eu-west-1-g2-2xlarge 

Bagaimana Build-dl4j-mnist-single-layer-java-app bekerja

Dari file YAML, kita melihat bahwa kita mendefinisikan langkah ini, pertama menggunakan gambar Docker, dan kemudian menjalankan skrip untuk membangun Uber JAR. Gambar buruh pelabuhan kami memiliki kustomisasi dependensi lingkungan build (mis. GraalVM JDK, Maven, dll.) Untuk membuat aplikasi Java. Kami tidak memberikan input atau parameter apa pun, karena ini adalah tahap perakitan. Setelah build berhasil, kami menyalin toples uber bernama MLPMnist-1.0.0-bin.jar (nama asli) ke folder / valohai / outputs (direpresentasikan sebagai $ {VH_OUTPUTS_DIR}). Segala sesuatu di folder ini secara otomatis disimpan dalam penyimpanan proyek Anda, misalnya, di tempat sampah AWS S3. Akhirnya, kami mendefinisikan pekerjaan kami untuk AWS.

Bagaimana cara kerja Run-dl4j-mnist-single-layer-train-model

Semantik definisi ini mirip dengan langkah sebelumnya, kecuali bahwa kami menetapkan dua input: satu untuk tabung uber (MLPMnist-1.0.0.jar), dan yang lain untuk kumpulan data (dibongkar ke folder $ {HOME} /. Deeplearning4j). Kami akan melewati dua parameter - - kereta reaksi dan --output-dir / valohai / output. Model yang dibuat pada langkah ini dibangun di / valohai / output / model (direpresentasikan sebagai $ {VH_OUTPUTS_DIR} / model).

Bagaimana cara kerja Run-dl4j-mnist-single-layer -valu-model

Sekali lagi, langkah ini mirip dengan langkah sebelumnya, kecuali bahwa kita akan melewati dua parameter - evaluasi aksi dan - input-dir / valohai / input / model. Selain itu, kami sekali lagi ditunjukkan dalam input: bagian yang didefinisikan dalam file YAML dengan nama dl4j-java-app dan model tanpa default untuk keduanya. Ini akan memungkinkan kita untuk memilih tabung uber dan model yang ingin kita evaluasi - yang dibuat menggunakan langkah Run-dl4j-mnist-single-layer-train-model menggunakan antarmuka web.

Saya harap ini menjelaskan langkah-langkah dalam file definisi di atas, tetapi jika Anda memerlukan bantuan lebih lanjut, silakan lihat dokumentasi dan tutorialnya .

Valohai Web Interface

Setelah menerima akun, kita dapat masuk dan melanjutkan membuat proyek dengan nama mlpmnist-single-layer dan mengaitkan git repo github.com/valohai/mlpmnist-dl4j-contoh dengan proyek dan menyimpan proyek.

Sekarang Anda dapat menyelesaikan langkah dan melihat bagaimana hasilnya!

Membangun Aplikasi Java DL4J

Buka tab "Eksekusi" di antarmuka web dan salin eksekusi yang ada atau buat yang baru menggunakan tombol [Buat eksekusi]. Semua parameter standar yang diperlukan akan diisi. Pilih Langkah Bangun-dl4j-mnist-single-layer-java-app.

Untuk Lingkungan, saya memilih AWS eu-west-1 g2.2xlarge dan mengklik tombol [Buat eksekusi] di bagian bawah halaman untuk melihat awal eksekusi.

Pelatihan model

Buka tab "Eksekusi" di antarmuka web dan lakukan hal yang sama seperti pada langkah sebelumnya, dan pilih Jalankan-dl4j-mnist-single-layer-train-model. Anda harus memilih aplikasi Java (cukup masukkan toples di bidang) yang dibuat pada langkah sebelumnya. Kumpulan data telah dipra-populasi menggunakan file valohai.yaml:



Klik [Buat Eksekusi] untuk memulai.



Anda akan melihat hasilnya di konsol:

 [<--- snipped --->] 11:17:05 ======================================================================= 11:17:05 LayerName (LayerType) nIn,nOut TotalParams ParamsShape 11:17:05 ======================================================================= 11:17:05 layer0 (DenseLayer) 784,1000 785000 W:{784,1000}, b:{1,1000} 11:17:05 layer1 (OutputLayer) 1000,10 10010 W:{1000,10}, b:{1,10} 11:17:05 ----------------------------------------------------------------------- 11:17:05 Total Parameters: 795010 11:17:05 Trainable Parameters: 795010 11:17:05 Frozen Parameters: 0 11:17:05 ======================================================================= [<--- snipped --->] 

Model yang dibuat dapat ditemukan pada tab "Output" dari tab utama "Eksekusi" selama dan setelah eksekusi:



Anda dapat melihat beberapa artefak di sub-tab Output. Ini karena kami mempertahankan titik kontrol di akhir setiap era. Mari kita lihat ini di log:

 [<--- snipped --->] 11:17:14 odolCheckpointListener - Model checkpoint saved: epoch 0, iteration 469, path: /valohai/outputs/checkpoint_0_MultiLayerNetwork.zip [<--- snipped --->] 

Pos pemeriksaan berisi keadaan model dalam tiga file:

 configuration.json coefficients.bin updaterState.bin 

Pelatihan model. Metadata

Anda mungkin telah memperhatikan entri ini di log eksekusi:

 [<--- snipped --->] 11:17:05 {"epoch": 0, "iteration": 0, "score (loss function)": 2.410047} 11:17:07 {"epoch": 0, "iteration": 100, "score (loss function)": 0.613774} 11:17:09 {"epoch": 0, "iteration": 200, "score (loss function)": 0.528494} 11:17:11 {"epoch": 0, "iteration": 300, "score (loss function)": 0.400291} 11:17:13 {"epoch": 0, "iteration": 400, "score (loss function)": 0.357800} 11:17:14 odolCheckpointListener - Model checkpoint saved: epoch 0, iteration 469, path: /valohai/outputs/checkpoint_0_MultiLayerNetwork.zip [<--- snipped --->] 

Data ini memungkinkan Valohai untuk mendapatkan nilai-nilai ini (dalam format JSON), yang akan digunakan untuk membangun metrik yang dapat dilihat selama dan setelah eksekusi pada tab Metadata tambahan pada tab utama Eksekusi:



Kami dapat melakukan ini dengan menghubungkan kelas ValohaiMetadataCreator ke model, sehingga Valohai merujuk ke kelas ini selama pelatihan. Dalam kasus kelas ini, kami memperoleh beberapa era, jumlah iterasi dan Skor (nilai fungsi kerugian). Berikut ini cuplikan kode dari kelas:

 public void iterationDone(Model model, int iteration, int epoch) { if (printIterations <= 0) printIterations = 1; if (iteration % printIterations == 0) { double score = model.score(); System.out.println(String.format( "{\"epoch\": %d, \"iteration\": %d, \"score (loss function)\": %f}", epoch, iteration, score) ); } } 

Evaluasi Model

Setelah model berhasil dibuat pada langkah sebelumnya, itu harus dievaluasi. Kami membuat Eksekusi baru dengan cara yang sama seperti sebelumnya, tetapi kali ini pilih langkah Run-dl4j-mnist-single-layer -valu-model. Kita perlu memilih aplikasi Java (MLPMnist-1.0.0.jar) dan model yang dibuat (mlpmnist-single-layer.pb) lagi sebelum memulai eksekusi (seperti yang ditunjukkan di bawah):



Setelah memilih model yang diinginkan sebagai input, klik tombol [Buat eksekusi]. Ini akan mengeksekusi lebih cepat dari yang sebelumnya, dan kita akan melihat hasil berikut:



Kami melihat bahwa "hello world" kami mengarah ke model yang akurasinya sekitar 97% berdasarkan kumpulan data uji. Matriks kebingungan membantu menemukan kasus ketika digit diprediksi secara salah sebagai digit lain.

Pertanyaannya tetap (dan di luar cakupan tulisan ini) - seberapa bagus model ketika dihadapkan dengan data nyata?

Untuk mengkloning repositori git, inilah yang perlu Anda lakukan:

  $ git clone https://github.com/valohai/mlpmnist-dl4j-example 

Maka kita perlu menautkan proyek Valohai kami, dibuat melalui antarmuka web pada bagian di atas, dengan proyek disimpan di mesin lokal kami (yang baru saja kami kloning). Jalankan perintah berikut untuk melakukan ini:

 $ cd mlpmnist-dl4j-example $ vh project --help ### to see all the project-specific options we have for Valohai $ vh project link 

Anda akan ditampilkan sesuatu seperti ini:

 [ 1] mlpmnist-single-layer ... Which project would you like to link with /path/to/mlpmnist-dl4j-example? Enter [n] to create a new project.: 

Pilih 1 (atau yang cocok untuk Anda) dan Anda akan melihat pesan ini:

 Success! Linked /path/to/mlpmnist-dl4j-example to mlpmnist-single-layer. 

Satu hal lagi, sebelum melanjutkan, pastikan proyek Valohai Anda selaras dengan proyek git terbaru dengan melakukan ini:

  $ vh project fetch 

Sekarang kita bisa menyelesaikan langkah-langkah dari CLI dengan:

  $ vh exec run Build-dl4j-mnist-single-layer-java-app 

Setelah Eksekusi selesai, kita dapat memeriksanya dengan:

 $ vh exec info $ vh exec logs $ vh exec watch 

Kesimpulan

Seperti yang telah kita lihat, sangat nyaman untuk bekerja dengan DL4J dan Valohai bersama-sama. Selain itu, kami dapat mengembangkan berbagai komponen yang membentuk eksperimen kami (penelitian), yaitu lingkungan build / runtime, kumpulan kode dan data, dan mengintegrasikannya ke dalam proyek kami.

Contoh template yang digunakan dalam posting ini adalah cara yang baik untuk mulai membuat proyek yang lebih kompleks. Dan Anda dapat menggunakan antarmuka baris perintah atau web untuk melakukan pekerjaan Anda dengan Valohai. Dengan CLI, Anda juga dapat mengintegrasikannya dengan instalasi dan skrip Anda (atau bahkan dengan pekerjaan CRON atau CI / CD).

Selain itu, jelas bahwa jika saya mengerjakan proyek yang terkait dengan AI / ML / DL, saya tidak perlu khawatir tentang membuat dan memelihara pipa end-to-end (yang banyak harus dilakukan di masa lalu).

Referensi

1. Proyek contoh mlpmnist-dl4j di GitHub
2. Sumber Daya AI / ML / DL Luar Biasa
3. Sumber Daya AI / ML / DL Java
4. Pembelajaran Jauh dan Sumber Daya DL4J

Terima kasih atas perhatian anda!