डीप लर्निंग अब जावा में है

जावा पसंद नहीं है? हां, आप इसे खाना बनाना नहीं जानते हैं! मणि सरकार ने हमें वलोहाई उपकरण से परिचित होने के लिए आमंत्रित किया है, जो आपको जावा में मॉडल अनुसंधान करने की अनुमति देता है।

परिचय

कुछ समय पहले, मैं वलोहाई नामक एक क्लाउड सेवा में आया था, और मैं इसके यूजर इंटरफेस और डिजाइन और लेआउट की सादगी से प्रसन्न था। मैंने वलोहाई के सदस्यों में से एक की सेवा मांगी और एक डेमो संस्करण प्राप्त किया। इससे पहले, मैंने जीएनयू समानांतर, जावास्क्रिप्ट, पायथन और बैश का उपयोग करके एक साधारण पाइपलाइन लिखी थी - और एक अन्य जो केवल जीएनयू समानांतर और बैश का उपयोग करता है।

मैंने जेन्किन्स एक्स, जेनकिंस पाइपलाइन, कॉनकोर्स या एयरफ्लो जैसे रेडी-टू-यूज़ टास्क / वर्कफ़्लो प्रबंधन टूल का उपयोग करने के बारे में भी सोचा, लेकिन विभिन्न कारणों से मैंने फैसला नहीं किया।

मैंने देखा कि कई वलोहाई उदाहरण और प्रलेखन पायथन और आर और उनके संबंधित ढांचे और पुस्तकालयों पर आधारित हैं। मैंने फैसला किया कि मैं मौका नहीं गंवाना चाहता और उदाहरणों और दस्तावेजीकरण की कमी को दूर करना चाहता हूं।

वालोहाई ने मुझे जावा के लिए डीएल 4 जे - डीप लर्निंग नामक प्रसिद्ध जावा लाइब्रेरी का उपयोग करके कुछ लागू करने के लिए प्रेरित किया।

वलोहाई के साथ मेरे पहले अनुभव ने अपने डिजाइन, लेआउट और वर्कफ़्लो के माध्यम से महसूस करने के बाद मुझ पर एक अच्छी छाप छोड़ी। निर्माता पहले ही डेवलपर के वर्कफ़्लो और बुनियादी ढांचे दोनों के विभिन्न पहलुओं को ध्यान में रखते हैं। हमारी दुनिया में, बुनियादी ढांचा विकास प्रक्रिया मुख्य रूप से DevOps या SysOps टीमों द्वारा नियंत्रित की जाती है, और हम इससे जुड़ी बारीकियों और दर्द बिंदुओं को जानते हैं।

हमें क्या और कैसे चाहिए?

किसी भी मशीन लर्निंग प्रोजेक्ट में, दो महत्वपूर्ण घटक होते हैं (एक उच्च-स्तरीय दृष्टिकोण से) - एक कोड जो मॉडल के साथ काम करेगा, और कोड जो बुनियादी ढांचे के साथ काम करेगा, जिसमें पूरे प्रोजेक्ट जीवन चक्र को निष्पादित किया जाएगा।

बेशक, पहले, दौरान और बाद में आवश्यक कदम और घटक होंगे, लेकिन सरलता के लिए, मान लीजिए, हमें कोड और बुनियादी ढांचे की आवश्यकता है।

कोड

कोड के लिए, मैंने DL4J का उपयोग करके एक जटिल उदाहरण चुना, यह एक MNist परियोजना है जिसमें 60,000 चित्रों का प्रशिक्षण सेट और हस्तलिखित अंकों की 10,000 छवियों का एक परीक्षण सेट है। यह डेटासेट DL4J लाइब्रेरी (Keras की तरह) के माध्यम से उपलब्ध है।

शुरू करने से पहले, यह अनुशंसा की जाती है कि आप उस स्रोत कोड पर एक नज़र डालें जिसका हम उपयोग करेंगे। मुख्य जावा वर्ग को org.deeplearning4j.feedforward.mnist.MLPMnistSingleLayerRunner कहा जाता है।

आधारभूत संरचना

हमने प्रयोगों (प्रशिक्षण और मॉडल मूल्यांकन) के संचालन के लिए हमारे बुनियादी ढांचे के रूप में वलोहाई का उपयोग करके जावा उदाहरण की कोशिश करने का फैसला किया। वलोहाई जीआईटी रिपॉजिटरी को पहचानते हैं और उनसे सीधे जुड़ते हैं, जिससे हमें प्लेटफ़ॉर्म या भाषा की परवाह किए बिना हमारे कोड को निष्पादित करने की अनुमति मिलती है - इसलिए हम देखेंगे कि यह कैसे काम करता है। इसका अर्थ यह भी है कि यदि आप GitOps या Infrastructure-As-Code का उपयोग करते हैं, तो सब कुछ आपके लिए भी काम करेगा।

ऐसा करने के लिए, हमें बस वलोहई में एक खाते की आवश्यकता है। एक मुफ्त खाता बनाने के बाद, हमें विभिन्न कॉन्फ़िगरेशन के कई उदाहरणों तक पहुंच मिलती है। हम जो करना चाहते हैं, उसके लिए Free-Tier पर्याप्त है।

जावा और वलोहाई के लिए डीप लर्निंग

हम डॉकर छवि के लिए सभी निर्भरताएं प्रदान करेंगे और इसका उपयोग हमारे जावा एप्लिकेशन को संकलित करने, मॉडल को प्रशिक्षित करने और प्रोजेक्ट रिपॉजिटरी के रूट फ़ोल्डर में स्थित एक साधारण वाल्वोइअम.एलएल फाइल का उपयोग करके वलोहाई प्लेटफॉर्म पर मूल्यांकन करने के लिए करेंगे।

जावा के लिए डीप लर्निंग: डीएल 4 जे

सबसे सरल भाग। हमें ज्यादा कुछ नहीं करना है, बस जार को इकट्ठा करें और डॉकटर कंटेनर में डेटासेट लोड करें। हमारे पास एक पूर्व-निर्मित डॉकर छवि है जिसमें जावा एप्लिकेशन बनाने के लिए आवश्यक सभी निर्भरताएं हैं। हमने इस छवि को डॉकर हब में रखा, और आप इसे dl4j-mnist-सिंगल-लेयर की खोज करके पा सकते हैं (हम एक विशेष टैग का उपयोग करेंगे जैसा कि YAML फाइल में परिभाषित है)। हमने इस परियोजना के लिए हमारे बिल्ड और रनटाइम जावा वातावरण के रूप में GraalVM 19.1.1 का उपयोग करने का फैसला किया, और इसे डॉकिंग इमेज में बनाया गया है।

जब uber जार को कमांड लाइन से बुलाया जाता है, तो हम MLPMnistSingleLayerRunner क्लास बनाते हैं, जो हमें दिए गए मापदंडों के आधार पर, इच्छित कार्रवाई बताता है:

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

Uber जार में पारित पैरामीटर इस वर्ग द्वारा स्वीकार किए जाते हैं और निष्पादित () विधि द्वारा संसाधित होते हैं।

हम -एक्शन ट्रेन पैरामीटर का उपयोग करके एक मॉडल बना सकते हैं और जावा एप्लिकेशन को पास किए गए -एवीएशन मूल्यांकन पैरामीटर का उपयोग करके बनाए गए मॉडल का मूल्यांकन कर सकते हैं।

जावा एप्लिकेशन के मुख्य भाग जो यह काम करते हैं, उन्हें नीचे दिए गए अनुभागों में वर्णित दो जावा कक्षाओं में पाया जा सकता है।

मॉडल प्रशिक्षण

कॉल

 ./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} 

यह कमांड निष्पादन के प्रारंभ में दिए गए --output-dir पैरामीटर द्वारा निर्दिष्ट फ़ोल्डर में mlpmnist-single-layer.pb नाम का एक मॉडल बनाता है। वलोहाई के दृष्टिकोण से, इसे $ {VH_OUTPUTS_DIR} में रखा जाना चाहिए, जो कि हम करते हैं (फाइल वलोहै.मय्ल देखें)।

स्रोत कोड के लिए, MLPMNistSingleLayerTrain.java वर्ग देखें।

मॉडल का मूल्यांकन

कॉल

 ./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 

यह माना जाता है कि मॉडल (प्रशिक्षण चरण के दौरान बनाया गया) का नाम mlpmnist-single-layer.pb के साथ मौजूद फ़ोल्डर में मौजूद होगा, जिसे --input-dir पैरामीटर में निर्दिष्ट किया गया था जब एप्लिकेशन को कॉल किया गया था।

स्रोत कोड के लिए, क्लास MLPMNistSingleLayerEvaluate.java देखें।

मुझे उम्मीद है कि यह लघु चित्रण स्पष्ट करता है कि एक जावा एप्लिकेशन कैसे सिखाता है और एक मॉडल का मूल्यांकन करता है।

यह वह सब है जो हमारे लिए आवश्यक है, लेकिन बाकी स्रोतों ( README.md और bash स्क्रिप्ट के साथ) के साथ खेलने में संकोच न करें और अपनी जिज्ञासा और संतुष्टि को समझें कि यह कैसे किया जाता है!

Valohai

Valohai हमें स्वतंत्र रूप से हमारे रनटाइम, कोड और डेटासेट को जोड़ने की अनुमति देता है, जैसा कि आप नीचे दिए गए YAML फ़ाइल संरचना से देख सकते हैं। इस प्रकार, विभिन्न घटक एक-दूसरे से स्वतंत्र रूप से विकसित हो सकते हैं। नतीजतन, केवल विधानसभा और रनटाइम घटक हमारे डॉकर कंटेनर में पैक किए जाते हैं।

रन समय में, हम उबेर जार को एक डॉकटर कंटेनर में इकट्ठा करते हैं, इसे कुछ आंतरिक या बाहरी भंडारण में लोड करते हैं, और फिर प्रशिक्षण शुरू करने के लिए भंडारण (या अन्य जगह) से उबर जार और डेटासेट को लोड करने के लिए अन्य निष्पादन चरण का उपयोग करते हैं। इस प्रकार, दो निष्पादन चरणों को काट दिया जाता है; उदाहरण के लिए, हम एक बार जार संकलित कर सकते हैं और एक ही जार पर सैकड़ों प्रशिक्षण चरण पूरे कर सकते हैं। क्योंकि असेंबली और रनटाइम वातावरण को इतनी बार बदलना नहीं पड़ता है, हम उन्हें कैश कर सकते हैं, और कोडटाइम, डेटासेट और मॉडल रनटाइम पर गतिशील रूप से सुलभ हो सकते हैं।

valohai.yaml
वलोहाई इंफ्रास्ट्रक्चर के साथ हमारे जावा प्रोजेक्ट को एकीकृत करने का मुख्य भाग आपके प्रोजेक्ट फ़ोल्डर की जड़ में स्थित वलोहाई.इमएल फ़ाइल में निष्पादन चरणों का क्रम निर्धारित करना है। हमारे वल्हाई.यामल ऐसे दिखते हैं:

 --- - 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 

बिल्ड-डीएल 4 जे-एमनिस्ट-सिंगल-लेयर-जावा-ऐप कैसे काम करता है

YAML फ़ाइल से, हम देखते हैं कि हम इस कदम को परिभाषित करते हैं, पहले डॉकर छवि का उपयोग करते हैं, और फिर उबर जार बनाने के लिए स्क्रिप्ट चला रहे हैं। हमारी डॉकटर छवि में जावा अनुप्रयोग बनाने के लिए बिल्ड एनवायरनमेंट डिपेंडेंसीज़ (जैसे ग्रेवलम जेडीके, मेवेन, आदि) का अनुकूलन है। हम कोई इनपुट या पैरामीटर प्रदान नहीं करते हैं, क्योंकि यह विधानसभा चरण है। एक बार निर्माण सफल होने के बाद, हम MLPMnist-1.0.0-bin.jar (मूल नाम) के uber जार को / valohai / आउटपुट फ़ोल्डर में कॉपी करते हैं ($ {VH_OUTPUTS_DIR} के रूप में प्रतिनिधित्व)। इस फ़ोल्डर में सब कुछ स्वचालित रूप से आपकी परियोजना के भंडारण में सहेजा जाता है, उदाहरण के लिए, एडब्ल्यूएस एस 3 रीसायकल बिन में। अंत में, हम AWS के लिए अपने काम को परिभाषित करते हैं।

रन-डीएल 4 जे-एमनिस्ट-सिंगल-लेयर-ट्रेन-मॉडल कैसे काम करता है

परिभाषा के शब्दार्थ पिछले चरण के समान हैं, सिवाय इसके कि हम दो इनपुट निर्दिष्ट करते हैं: एक uber जार (MLPMnist-1.0.0.jar) के लिए, और दूसरा डेटा सेट के लिए (फ़ोल्डर $ $ $ "HD / / Deeplearning4j में)। हम दो मापदंडों को पार करेंगे - - निष्क्रियता ट्रेन और --आउटपुट-दिर / वलोहाई / आउटपुट। इस चरण में बनाया गया मॉडल / वलोहाई / आउटपुट / मॉडल ($ {VH_OUTPUTS_DIR} / मॉडल के रूप में प्रतिनिधित्व) में बनाया गया है।

रन-डीएल 4 जे-एमनिस्ट-सिंगल-लेयर -वालु-मॉडल कैसे काम करता है

फिर से, यह चरण पिछले चरण के समान है, सिवाय इसके कि हम दो मापदंडों - निष्क्रियता मूल्यांकन और --input-dir / valohai / निविष्टियाँ / मॉडल को पारित करेंगे। इसके अलावा, हमने फिर से इनपुट में संकेत दिया: इन दोनों के लिए डिफ़ॉल्ट के बिना dl4j-java-app और मॉडल के साथ YAML फ़ाइल में परिभाषित अनुभाग। यह हमें uber जार और उस मॉडल का चयन करने की अनुमति देगा जिसका हम मूल्यांकन करना चाहते हैं - जो वेब इंटरफ़ेस का उपयोग करके रन-dl4j-mnist-सिंगल-लेयर-ट्रेन-मॉडल चरण का उपयोग करके बनाया गया था।

मुझे आशा है कि यह ऊपर दी गई परिभाषा फ़ाइल में दिए गए चरणों की व्याख्या करता है, लेकिन यदि आपको और सहायता की आवश्यकता है, तो कृपया दस्तावेज़ और ट्यूटोरियल देखने के लिए स्वतंत्र महसूस करें।

वलोहाई वेब इंटरफ़ेस

खाता प्राप्त करने के बाद, हम लॉग-इन कर सकते हैं और इस प्रोजेक्ट को mlpmnist-सिंगल-लेयर और एसोसिएट git रेपो github.com/valohai/mlpmnist-dl4j-example नाम से प्रोजेक्ट बनाकर प्रोजेक्ट को सेव कर सकते हैं।

अब आप चरण को पूरा कर सकते हैं और देखें कि यह कैसे निकलता है!

एक DL4J जावा अनुप्रयोग बनाएँ

वेब इंटरफ़ेस में "निष्पादन" टैब पर जाएं और मौजूदा निष्पादन को कॉपी करें या [क्रिएट एक्जीक्यूट] बटन का उपयोग करके एक नया बनाएं। सभी आवश्यक डिफ़ॉल्ट पैरामीटर भरे जाएंगे। स्टेप बिल्ड- dl4j-mnist-सिंगल-लेयर-जावा-ऐप का चयन करें।

पर्यावरण के लिए, मैंने निष्पादन की शुरुआत देखने के लिए पृष्ठ के निचले भाग पर AWS eu-west-1 g2.2xlarge का चयन किया और [क्रिएट एक्जीक्यूशन] बटन पर क्लिक किया।

मॉडल प्रशिक्षण

वेब इंटरफ़ेस में "निष्पादन" टैब पर जाएं और पिछले चरण के समान ही करें, और Run-dl4j-mnist-सिंगल-लेयर-ट्रेन-मॉडल का चयन करें। आपको पिछले चरण में बनाए गए जावा एप्लिकेशन (बस फ़ील्ड में जार दर्ज करें) का चयन करना होगा। डेटा सेट को पहले से ही valohai.yaml फ़ाइल का उपयोग करके पहले से ही आबाद कर दिया गया है:



प्रारंभ करने के लिए [निष्पादन बनाएं] पर क्लिक करें।



आप कंसोल में परिणाम देखेंगे:

 [<--- 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 --->] 

बनाए गए मॉडल निष्पादन के दौरान और बाद में "निष्पादन" मुख्य टैब के "आउटपुट" टैब पर पाए जा सकते हैं:



आप आउटपुट उप टैब में कई कलाकृतियों को देख सकते हैं। ऐसा इसलिए है क्योंकि हम प्रत्येक युग के अंत में नियंत्रण बिंदु बनाए रखते हैं। आइए इस लॉग में देखें:

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

चेकपॉइंट में तीन फ़ाइलों में मॉडल की स्थिति होती है:

 configuration.json coefficients.bin updaterState.bin 

मॉडल प्रशिक्षण। मेटाडाटा

आपने इन प्रविष्टियों को निष्पादन लॉग में देखा होगा:

 [<--- 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 --->] 

यह डेटा वलोहाई को इन मूल्यों को प्राप्त करने की अनुमति देता है (JSON प्रारूप में), जिसका उपयोग मेट्रिक्स के निर्माण के लिए किया जाएगा, जो कि एक्ज़िट्यूशन मुख्य टैब पर अतिरिक्त मेटाडेटा टैब पर निष्पादन के दौरान और बाद में देखा जा सकता है:



हम मॉडल के लिए वलोहइमाटाटाटाक्रेटर वर्ग को जोड़कर ऐसा करने में सक्षम थे, ताकि वलोहाई प्रशिक्षण के दौरान इस वर्ग को देखें। इस वर्ग के मामले में, हम कई युग, पुनरावृत्तियों की संख्या और स्कोर (नुकसान फ़ंक्शन का मूल्य) प्राप्त करते हैं। यहाँ कक्षा से कोड का एक स्निपेट दिया गया है:

 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) ); } } 

मॉडल का मूल्यांकन

एक बार मॉडल को पिछले चरण में सफलतापूर्वक बनाया गया है, इसका मूल्यांकन किया जाना चाहिए। हम पहले की तरह ही एक नया निष्पादन बनाते हैं, लेकिन इस बार Run-dl4j-mnist-सिंगल-लेयर -वालू-मॉडल चरण का चयन करें। हमें निष्पादन शुरू करने से पहले जावा एप्लिकेशन (MLPMnist-1.0.0.jar) और निर्मित मॉडल (mlpmnist-single-layer.pb) को फिर से चुनना होगा (जैसा कि नीचे दिखाया गया है):



इनपुट के रूप में वांछित मॉडल का चयन करने के बाद, [निष्पादन बनाएं] बटन पर क्लिक करें। यह पिछले एक की तुलना में तेजी से निष्पादित करेगा, और हम निम्नलिखित परिणाम देखेंगे:



हम देखते हैं कि हमारी "हैलो दुनिया" एक मॉडल के लिए नेतृत्व करती है जिसकी सटीकता परीक्षण डेटा सेट के आधार पर लगभग 97% है। कन्फ्यूजन मैट्रिक्स उन मामलों को खोजने में मदद करता है जब एक अंक को दूसरे अंक के रूप में गलत भविष्यवाणी की गई थी।

प्रश्न बना हुआ है (और इस पद के दायरे से परे) - वास्तविक डेटा का सामना करने पर मॉडल कितना अच्छा है?

एक गैट रिपॉजिटरी को क्लोन करने के लिए, यहाँ आपको क्या करना है:

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

फिर हमें अपने वलोहाई प्रोजेक्ट को लिंक करने की आवश्यकता है, जो ऊपर के अनुभाग में वेब इंटरफेस के माध्यम से बनाई गई है, हमारे स्थानीय मशीन (जिसे हम अभी क्लोन करते हैं) पर संग्रहीत प्रोजेक्ट के साथ। ऐसा करने के लिए निम्न आदेश चलाएँ:

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

आपको कुछ इस तरह दिखाया जाएगा:

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

1 का चयन करें (या जो आपको सूट करता है) और आपको यह संदेश देखना चाहिए:

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

एक और बात, आगे बढ़ने से पहले, सुनिश्चित करें कि आपका वलोहाई प्रोजेक्ट ऐसा करने से नवीनतम गिट प्रोजेक्ट के साथ तालमेल बैठा रहा है:

  $ vh project fetch 

अब हम CLI से चरणों को पूरा कर सकते हैं:

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

निष्पादन हो जाने के बाद, हम इसकी जाँच कर सकते हैं:

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

निष्कर्ष

जैसा कि हमने देखा है, DL4J और Valohai के साथ काम करना बहुत सुविधाजनक है। इसके अलावा, हम अपने प्रयोगों (अनुसंधान), यानी बिल्ड / रनटाइम पर्यावरण, कोड और डेटा सेट को बनाने वाले विभिन्न घटकों को विकसित कर सकते हैं और उन्हें हमारी परियोजना में एकीकृत कर सकते हैं।

इस पोस्ट में उपयोग किए गए नमूना टेम्पलेट अधिक जटिल प्रोजेक्ट बनाने का एक अच्छा तरीका है। और आप अपना काम Valohai के साथ करने के लिए वेब या कमांड लाइन इंटरफ़ेस का उपयोग कर सकते हैं। सीएलआई के साथ, आप इसे अपने इंस्टॉलेशन और स्क्रिप्ट्स (या यहां तक ​​कि CRON या CI / CD जॉब्स के साथ भी एकीकृत कर सकते हैं)।

इसके अलावा, यह स्पष्ट है कि अगर मैं एआई / एमएल / डीएल से संबंधित परियोजना पर काम कर रहा हूं, तो मुझे एंड-टू-एंड पाइप लाइन बनाने और बनाए रखने के बारे में चिंता करने की आवश्यकता नहीं है (जो कि कई अन्य लोगों को अतीत में करना था)।

संदर्भ

1. GitHub पर mlpmnist-dl4j- उदाहरण प्रोजेक्ट
2. बहुत बढ़िया ऐ / एमएल / डीएल संसाधन
3. जावा एआई / एमएल / डीएल संसाधन
4. डीप लर्निंग और DL4J संसाधन

आपका ध्यान के लिए धन्यवाद!