सभी को नमस्कार! एमएल-मॉडल के निर्माण में पायथन आज एक अग्रणी स्थान पर है और डेटा विज्ञान विशेषज्ञों के समुदाय के बीच व्यापक रूप से लोकप्रिय है [ 1 ]।

अधिकांश डेवलपर्स की तरह, अजगर अपनी सरलता और संक्षिप्त वाक्य रचना के साथ हमें आकर्षित करता है। हम इसका उपयोग कृत्रिम तंत्रिका नेटवर्क का उपयोग करके मशीन सीखने की समस्याओं को हल करने के लिए करते हैं। हालांकि, व्यवहार में, उत्पाद विकास भाषा हमेशा पायथन नहीं होती है, और इससे हमें अतिरिक्त एकीकरण समस्याओं को हल करने की आवश्यकता होती है।

इस लेख में मैं उन समाधानों के बारे में बात करूंगा जो हमें तब आए थे जब हमें जावा के साथ पायथन के केरस मॉडल को जोड़ने की आवश्यकता थी।

हम क्या ध्यान देते हैं:

बंडल केरस मॉडल और जावा सुविधाएँ;
DeepLearning4j ढांचे (शॉर्ट के लिए DL4J) के साथ काम करने की तैयारी;
DL4J में एक केरस मॉडल आयात करना (ध्यान से, अनुभाग में कई अंतर्दृष्टि शामिल हैं) - परतों को कैसे पंजीकृत किया जाए, आयात मॉड्यूल की क्या सीमाएं हैं, इसके कार्य के परिणामों की जांच कैसे करें।

क्यों पढ़ा?

शुरुआत में समय बचाने के लिए, यदि आप समान एकीकरण के कार्य का सामना करेंगे;
यह जानने के लिए कि क्या हमारा समाधान आपके लिए सही है और यदि आप हमारे अनुभव का पुन: उपयोग कर सकते हैं।

गहन शिक्षण ढांचे के महत्व पर अभिन्न विशेषता [ 2 ]।

सबसे लोकप्रिय गहरे सीखने के ढांचे का सारांश यहां [ 3 ] और यहां [ 4 ] पाया जा सकता है।

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

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

एक अन्य वैकल्पिक तरीका है, जावा बाइटकोड में संकलन करने के लिए ज्यथॉन का उपयोग करना; लेकिन यहां एक खामी है - केवल पायथन के दूसरे संस्करण के लिए समर्थन, साथ ही तीसरे पक्ष के पायथन पुस्तकालयों का उपयोग करने की सीमित क्षमता।

जावा में तंत्रिका नेटवर्क समाधानों के विकास को सरल बनाने के लिए, डीपीएलर्निंग 4 जे फ्रेमवर्क (डीएल 4 जे फॉर शॉर्ट) विकसित किया जा रहा है। जावा एपीआई के अलावा DL4 पूर्व-प्रशिक्षित मॉडल [ 5 ] का एक सेट प्रदान करता है। सामान्य तौर पर, यह विकास उपकरण TensorFlow के साथ प्रतिस्पर्धा करना मुश्किल है। अधिक विस्तृत प्रलेखन और कई उदाहरणों, तकनीकी क्षमताओं, सामुदायिक आकारों और तेजी से विकसित होने वाले विकास के साथ TensorFlow outperforms DL4J। फिर भी, स्काईमाइंड जिस प्रवृत्ति का पालन करता है, वह काफी आशाजनक है। इस उपकरण के लिए जावा में महत्वपूर्ण प्रतियोगी अभी तक दिखाई नहीं दे रहे हैं।

DL4J पुस्तकालय कुछ में से एक है (यदि केवल एक ही नहीं है) जो कि केरस-मॉडल को आयात करना संभव बनाता है, तो यह केरस से परिचित परतों के साथ कार्यक्षमता में फैलता है [ 6 ]। DL4J लाइब्रेरी में एक निर्देशिका है जिसमें तंत्रिका नेटवर्क ML-मॉडल (dl4j-example) के कार्यान्वयन के उदाहरण हैं। हमारे मामले में, जावा में इन मॉडलों को लागू करने की सूक्ष्मता इतनी दिलचस्प नहीं है। DL4J विधियों का उपयोग करके जावा में प्रशिक्षित केरस / TF मॉडल के आयात पर अधिक विस्तृत ध्यान दिया जाएगा।

शुरुआत हो रही है

शुरू करने से पहले, आपको आवश्यक कार्यक्रम स्थापित करने की आवश्यकता है:

जावा संस्करण 1.7 (64-बिट संस्करण) और उच्चतर।
अपाचे मावेन प्रोजेक्ट बिल्ड सिस्टम।
आईडीई से चुनने के लिए: Intellij IDEA, Eclipse, Netbeans। डेवलपर्स पहले विकल्प की सलाह देते हैं, और इसके अलावा, उपलब्ध प्रशिक्षण उदाहरणों पर चर्चा की जाती है।
गिट (अपने पीसी के लिए एक परियोजना क्लोनिंग के लिए)।

लॉन्च के उदाहरण के साथ एक विस्तृत विवरण यहां पाया जा सकता है [ 7 ] या वीडियो में [ 8 ]।

मॉडल को आयात करने के लिए, DL4J डेवलपर्स KerasModelImport आयात मॉड्यूल का उपयोग करने का सुझाव देते हैं (अक्टूबर 2016 में प्रदर्शित)। मॉड्यूल का कार्यात्मक कैरस से मॉडल के दोनों आर्किटेक्चर का समर्थन करता है - यह अनुक्रमिक है (जावा में एनालॉग - मल्टीलेयर नेटवर्क) और कार्यात्मक (जावा में एनालॉग - क्लास कम्प्यूटेशनग्राफ)। मॉडल या तो पूरे HDF5 प्रारूप में, या 2 अलग-अलग फ़ाइलों के रूप में आयात किया जाता है - h5 एक्सटेंशन के साथ मॉडल का वजन और तंत्रिका नेटवर्क आर्किटेक्चर युक्त json फ़ाइल।

एक त्वरित शुरुआत के लिए, DL4J डेवलपर्स ने एक प्रकार के अनुक्रमिक [ 9 ] मॉडल के लिए फिशर आईरिस डेटासेट पर एक सरल उदाहरण का चरण-दर-चरण विश्लेषण तैयार किया। एक अन्य प्रशिक्षण उदाहरण को दो तरीकों से मॉडल के परिप्रेक्ष्य से माना जाता था (1: पूरे एचडीएफ 5 प्रारूप में; 2: अलग-अलग फाइलों में - मॉडल वेट (एच 5 एक्सटेंशन) और आर्किटेक्चर (जोंस एक्सटेंशन)), जिसके बाद पायथन और जावा मॉडल [ 10 ] के परिणामों की तुलना की जाती है। यह आयात मॉड्यूल की व्यावहारिक क्षमताओं की चर्चा का निष्कर्ष निकालता है।

जावा में टीएफ भी है, लेकिन यह एक प्रयोगात्मक स्थिति में है और डेवलपर्स इसके स्थिर संचालन की कोई गारंटी नहीं देते हैं [ 11 ]। संस्करण के साथ समस्याएं हैं, और जावा में टीएफ में एक अधूरा एपीआई है - यही कारण है कि इस विकल्प को यहां नहीं माना जाएगा।

मूल केरस / TF मॉडल की विशेषताएं:

एक तंत्रिका नेटवर्क आयात करना सीधा है। कोड में अधिक विस्तार से हम वास्तुशिल्प के साथ तंत्रिका नेटवर्क के एकीकरण के एक उदाहरण का विश्लेषण करेंगे जो अधिक जटिल है।

आपको इस मॉडल के व्यावहारिक पहलुओं में नहीं जाना चाहिए, यह परतों के लिए लेखांकन के दृष्टिकोण से (विशेष रूप से, लैम्ब्डा परतों के पंजीकरण), कुछ सूक्ष्मताएं और आयात मॉड्यूल की सीमाओं, साथ ही साथ DL4J के रूप में भी संकेत है। व्यवहार में, प्रचलित बारीकियों को नेटवर्क आर्किटेक्चर में समायोजन की आवश्यकता हो सकती है, या DL4J के माध्यम से मॉडल लॉन्च करने के दृष्टिकोण को पूरी तरह से छोड़ देना चाहिए।

मॉडल सुविधाएँ:

1. मॉडल का प्रकार - कार्यात्मक (शाखा के साथ नेटवर्क);

2. प्रशिक्षण पैरामीटर (बैच का आकार, युग की संख्या) छोटे चुने गए हैं: बैच का आकार - 100, युग की संख्या - 10, प्रति युग चरण - 10;

3. 13 परतों, परतों का एक सारांश चित्र में दिखाया गया है:

लघु परत विवरण

input_1 - इनपुट परत, एक 2-आयामी टेंसर (मैट्रिक्स द्वारा दर्शाया गया) को स्वीकार करता है;
lambda_1 - उपयोगकर्ता परत, हमारे मामले में, टेंसर के TF में पैडिंग को एक ही संख्यात्मक मान बनाता है;
एम्बेडिंग_1 - पाठ डेटा के इनपुट अनुक्रम के लिए एंबेडिंग (वेक्टर प्रतिनिधित्व) बनाता है (3-डी के लिए 2-डी टेंसर परिवर्तित करता है);
conv1d_1 - 1-डी संकेंद्रित परत;
lstm_2 - LSTM लेयर (एम्बेडिंग_1 (नंबर 3) लेयर के बाद जाता है);
lstm_1 - LSTM लेयर (conv1d (नंबर 4) लेयर के बाद जाती है);
lambda_2 उपयोगकर्ता परत है जहां lstm_2 (नंबर 5) परत (लैम्ब्डा_1 (नंबर 2) परत में पैडिंग के विपरीत ऑपरेशन) के बाद टेंसर को काट दिया जाता है;
lambda_3 यूजर लेयर है जहाँ lstm_1 (नंबर 6) और conv1d_1 (नंबर 4) लेयर्स (लैम्ब्डा_1 (नंबर 2) लेयर में पैडिंग के विपरीत ऑपरेशन) के बाद टेन्सर को छोटा किया जाता है;
concatenate_1 - छोटी (नंबर 7) और (नंबर 8) परतों की बॉन्डिंग;
dense_1 - 8 न्यूरॉन्स की एक पूरी तरह से जुड़ी परत और एक घातीय रैखिक सक्रियण फ़ंक्शन "एलु";
बैच_नॉर्मलाइज़ेशन_1 - सामान्यीकरण की परत;
dense_2 - 1 न्यूरॉन और सिग्मॉइड सक्रियण फ़ंक्शन "सिग्मॉइड" की पूरी तरह से जुड़ी हुई परत;
lambda_4 - एक उपयोगकर्ता परत जहां पिछली परत का संपीड़न (TF में निचोड़) किया जाता है।

4. हानि समारोह - बाइनरी_क्रोसेंट्रॉपी

ह ा न ि = - f r a c 1 N s u m_{1}^{N} (y_{t r u e} c d o t ल ॉ ग (y_{प ू र ् व}) + ((1 - y_{t r u e}) c d o t ल ॉ ग (1 - y_{प ू र ् व}))

$हानि = - \ frac {1} {N} \ sum_ {1} ^ {N} (y_ {true} \ cdot लॉग (y_ {पूर्व}) + ((1-y_ {true}) \ cdot लॉग (1- y_ {पूर्व}))$

5. मॉडल गुणवत्ता मीट्रिक - हार्मोनिक माध्य (एफ-माप)

F = 2 f r a c प र ि श ु द ् ध त ा ग ु न ा य ा द स ट ी क + य ा द

$F = 2 \ frac {परिशुद्धता \ गुना याद} {सटीक + याद}$

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

DL4J में Keras मॉडल आयात करें:

प्रयुक्त संस्करण: Tensorflow 1.5.0 और Keras 2.2.5। हमारे मामले में, पायथन से मॉडल को HDF5 फ़ाइल द्वारा पूरे अपलोड किया गया था।

# saving model model1.save('model1_functional.h5')

मॉडल को DL4J में आयात करते समय, आयात मॉड्यूल अतिरिक्त मापदंडों को पारित करने के लिए एपीआई तरीके प्रदान नहीं करता है: टेंसोफ़्लो मॉड्यूल का नाम (जहां मॉडल का निर्माण करते समय फ़ंक्शन आयात किए गए थे)।

सामान्यतया, डीएल 4 जे केवल केरस कार्यों के साथ काम करता है, केरस आयात अनुभाग [ 6 ] में एक विस्तृत सूची दी गई है, इसलिए यदि मॉडल टीएफ (हमारे मामले में) के तरीकों का उपयोग करके केरेस पर बनाया गया था, तो आयात मॉड्यूल उनकी पहचान नहीं कर पाएगा।

मॉडल आयात करने के लिए सामान्य दिशानिर्देश

जाहिर है, केरस-मॉडल के साथ काम करने का अर्थ है इसके दोहराया प्रशिक्षण। इस समय तक, समय बचाने के लिए, प्रशिक्षण पैरामीटर निर्धारित किए गए थे (1 युग) और प्रति चरण 1 चरण (चरण_पर_पॉच)।

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

TF हानि फ़ंक्शन का उपयोग करना

यह साबित करने के लिए कि, जब जावा में आयात किया जाता है, तो प्रशिक्षित मॉडल का नुकसान फ़ंक्शन कैरस से होना चाहिए, हम टेंसोफ़्लो से log_loss (custom_loss फ़ंक्शन के समान सबसे अधिक) का उपयोग करते हैं। कंसोल में हमें निम्न त्रुटि मिलती है:

 Exception in thread "main" org.deeplearning4j.nn.modelimport.keras.exceptions.UnsupportedKerasConfigurationException: Unknown Keras loss function log_loss.

केरस के साथ TF विधियों की जगह

हमारे मामले में, TF मॉड्यूल से फ़ंक्शन 2 बार उपयोग किए जाते हैं और सभी मामलों में वे केवल लैम्ब्डा परतों में पाए जाते हैं।

लैंबडा लेयर कस्टम लेयर हैं जिनका उपयोग एक मनमाना फ़ंक्शन जोड़ने के लिए किया जाता है।

हमारे मॉडल में केवल 4 लंबोदर परतें हैं। तथ्य यह है कि जावा में इन लैम्बडा परतों को KerasLayer.registerLambdaLayer के माध्यम से मैन्युअल रूप से पंजीकृत करना आवश्यक है (अन्यथा हमें एक त्रुटि मिलती है [ 12 ])। इस मामले में, लैम्ब्डा परत के अंदर परिभाषित फ़ंक्शन, संबंधित जावा लाइब्रेरीज़ से एक फ़ंक्शन होना चाहिए। जावा में इन परतों को पंजीकृत करने के कोई उदाहरण नहीं हैं, साथ ही इसके लिए व्यापक दस्तावेज भी हैं; एक उदाहरण यहाँ है [ १३ ]। सामान्य विचार उदाहरण [ 14 , 15 ] से उधार लिए गए थे।

जावा में मॉडल के सभी लैम्ब्डा परतों को पंजीकृत करने के क्रमिक रूप से विचार करें:

1) टैंसर (मैट्रिक्स) में स्थिरांक जोड़ने के लिए लम्बे परत दी गई दिशाओं के साथ कई बार (हमारे मामले में, बाएं और दाएं) दिशा:

इस परत का इनपुट मॉडल के इनपुट से जुड़ा है।

1.1) पायथन परत:

 padding = keras.layers.Lambda(lambda x: tf.pad(x, paddings=[[0, 0], [10, 10]], constant_values=1))(embedding)

स्पष्टता के लिए, इस परत के कार्य, हम अजगर परतों में संख्यात्मक मूल्यों को स्पष्ट रूप से प्रतिस्थापित करते हैं।

एक मनमाना टेंसर 2x2 के उदाहरण के साथ तालिका

यह 2x2 था	यह 2x22 हो गया है
[[ १ , २ ], [ ३ , ४ ]]	[[37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 1 , 2 , 37, 37, 37, 37, 37, 37, 37, 37, 37, 37] [37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 3 , 4 , 37, 37, 37, 37, 37, 37, 37, 37, 37, 37]]

1.2) जावा परत:

 KerasLayer.registerLambdaLayer("lambda_1", new SameDiffLambdaLayer() { @Override public SDVariable defineLayer(SameDiff sameDiff, SDVariable sdVariable) { return sameDiff.nn().pad(sdVariable, new int[][]{ { 0, 0 }, { 10, 10 }}, 1); } @Override public InputType getOutputType(int layerIndex, InputType inputType) { return InputType.feedForward(20); } });

जावा में सभी पंजीकृत लैम्ब्डा परतों में, 2 कार्यों को फिर से परिभाषित किया गया है:
पहला फ़ंक्शन "निश्चित" इस्तेमाल की गई विधि के लिए ज़िम्मेदार है (बिल्कुल स्पष्ट तथ्य पर नहीं: इस विधि का उपयोग केवल nn () बैकएंड से किया जा सकता है); getOutputType पंजीकृत परत के आउटपुट के लिए जिम्मेदार है, तर्क एक संख्यात्मक पैरामीटर है (यहां 20, लेकिन सामान्य तौर पर किसी भी पूर्णांक मूल्य की अनुमति है)। यह असंगत दिखता है, लेकिन यह इस तरह काम करता है।

2) दिए गए निर्देशों (हमारे मामले में, बाएं और दाएं) के साथ टैंसर (मैट्रिक्स) को ट्रिम करने के लिए लैम्ब्डा परत:

इस स्थिति में, LSTM परत लैम्ब्डा परत के इनपुट में प्रवेश करती है।

2.1) पायथन परत:

 slicing_lstm = keras.layers.Lambda(lambda x: x[:, 10:-10])(lstm)

एक मनमाना टेंसर 2x22x5 के उदाहरण के साथ तालिका

यह 2x22x5 था

यह 2x2x5 बन गया है

[[[1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1 , 2,3,4,5], [1,2,3,4,5], [ 1 , 2 , 3 , 4 , 5 ], [ 1 , 2 , 3 , 4 , 5 ], [1,2 , 3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3] , 4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4] , 5], [1,2,3,4,5]],

[[1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [[ 1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1, 2,3,4,5], [1,2,3,4,5], [ 1 , 2 , 3 , 4 , 5 ], [ 1 , 2 , 3 , 4 , 5 ], [1,2, 3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,] 4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5,] 5], [1,2,3,4,5]]

[[[ १ , २ , ३ , ४ , ५ ], [ १ , २ , ३ , ४ , ५ ]],
[[ १ , २ , ३ , ४ , ५ ], [ १ , २ , ३ , ४ , ५ ]]]

2.2) जावा परत:

 KerasLayer.registerLambdaLayer("lambda_2", new SameDiffLambdaLayer() { @Override public SDVariable defineLayer(SameDiff sameDiff, SDVariable sdVariable) { return sameDiff.stridedSlice(sdVariable, new int[]{ 0, 0, 10 }, new int[]{ (int)sdVariable.getShape()[0], (int)sdVariable.getShape()[1], (int)sdVariable.getShape()[2]-10}, new int[]{ 1, 1, 1 }); } @Override public InputType getOutputType(int layerIndex, InputType inputType) { return InputType.recurrent(60); } });

इस परत के मामले में, इनपुटटाइप पैरामीटर फीडफोर्वर्ड (20) से बदलकर आवर्तक (60) में बदल गया। आवर्तक तर्क में, संख्या किसी भी पूर्णांक (नॉनजेरो) हो सकती है, लेकिन अगली लैम्ब्डा परत के आवर्तक तर्क के साथ इसका योग 160 (यानी, अगली परत में, तर्क 100 होना चाहिए)। संख्या 160 इस तथ्य के कारण है कि आयाम के साथ टेंसर (कोई नहीं, कोई नहीं, 160) को परत के इनपुट concatenate_1 पर प्राप्त किया जाना चाहिए।

इनपुट स्ट्रिंग के आकार के आधार पर पहले 2 तर्क चर हैं।

3) दिए गए निर्देशों (हमारे मामले में, बाएं और दाएं) के साथ टैंसर (मैट्रिक्स) को ट्रिम करने के लिए लैम्ब्डा परत:

इस लेयर का इनपुट LSTM लेयर है, जिसके सामने conv1_d लेयर है

3.1) पायथन परत:

 slicing_convolution = keras.layers.Lambda(lambda x: x[:,10:-10])(lstm_conv)

यह ऑपरेशन पैराग्राफ 2.1 में ऑपरेशन के समान है।

3.2) जावा परत:

 KerasLayer.registerLambdaLayer("lambda_3", new SameDiffLambdaLayer() { @Override public SDVariable defineLayer(SameDiff sameDiff, SDVariable sdVariable) { return sameDiff.stridedSlice(sdVariable, new int[]{ 0, 0, 10 }, new int[]{ (int)sdVariable.getShape()[0], (int)sdVariable.getShape()[1], (int)sdVariable.getShape()[2]-10}, new int[]{ 1, 1, 1 }); } @Override public InputType getOutputType(int layerIndex, InputType inputType) { return InputType.recurrent(100); } });

यह लैम्ब्डा लेयर पिछले लैम्बडा लेयर को पुनरावृत्ति (100) पैरामीटर के अपवाद के साथ दोहराता है। क्यों "100" लिया जाता है पिछली परत के विवरण में नोट किया गया है।

अंक 2 और 3 में, लैम्ब्डा परतें LSTM परतों के बाद स्थित होती हैं, इसलिए आवर्तक प्रकार का उपयोग किया जाता है। लेकिन अगर लैम्ब्डा-लेयर से पहले LSTM नहीं था, लेकिन conv1d_1, तो फिर भी आवर्तक सेट करना आवश्यक है (यह असंगत दिखता है, लेकिन यह उसी तरह काम करता है)।

4) पिछली परत को संपीड़ित करने के लिए लैम्बडा परत:

इस परत का इनपुट पूरी तरह से जुड़ा हुआ परत है।

4.1) पायथन परत:

  squeeze = keras.layers.Lambda(lambda x: tf.squeeze( x, axis=-1))(dense)

एक मनमाना टेंसर 2x4x1 के उदाहरण के साथ तालिका

यह 2x4x1 था	2x4 बन गया
[[[ [१], [२], [३], [४]] , [ [१], [२], [३], [४] ]]	[[ १, २, ३, ४ ], [ १, २, ३, ४ ]]

4.2) जावा परत:

 KerasLayer.registerLambdaLayer("lambda_4", new SameDiffLambdaLayer() { @Override public SDVariable defineLayer(SameDiff sameDiff, SDVariable sdVariable) { return sameDiff.squeeze(sdVariable, -1); } @Override public InputType getOutputType(int layerIndex, InputType inputType) { return InputType.feedForward(15); } });

इस परत के इनपुट को एक पूरी तरह से जुड़ा हुआ परत प्राप्त होता है, इस परत के लिए इनपुट टाइप फीड 15 (15), पैरामीटर 15 मॉडल को प्रभावित नहीं करता है (किसी भी पूर्णांक मान की अनुमति है)।

आयातित मॉडल डाउनलोड करें

मॉडल को ComputationGraph मॉड्यूल के माध्यम से लोड किया गया है:

 ComputationGraph model = org.deeplearning4j.nn.modelimport.keras.KerasModelImport.importKerasModelAndWeights("/home/user/Models/model1_functional.h5");

जावा कंसोल को डेटा आउटपुट

जावा में, विशेष रूप से DL4J में, दसियों को उच्च-प्रदर्शन वाले Nd4j लाइब्रेरी से सरणियों के रूप में लिखा जाता है, जिसे पायथन में नेम्पी लाइब्रेरी का एक एनालॉग माना जा सकता है।

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

उदाहरण के लिए, हमारे पास 4 इंडेक्स-एन्कोडेड वर्ण हैं: 1, 3, 4, 8।

जावा में कोड:

 INDArray myArray = Nd4j.zeros(1,4); // one row 4 column array myArray.putScalar(0,0,1); myArray.putScalar(0,1,3); myArray.putScalar(0,2,4); myArray.putScalar(0,3,8); INDArray output = model.outputSingle(myArray); System.out.println(output);

कंसोल प्रत्येक इनपुट तत्व की संभावनाओं को प्रदर्शित करेगा।

आयातित मॉडल

मूल तंत्रिका नेटवर्क और वजन की वास्तुकला त्रुटियों के बिना आयात की जाती है। कार्नेस और जावा न्यूरल नेटवर्क मॉडल दोनों इंफ्रेंस मोड में परिणामों पर सहमत हैं।

पायथन मॉडल:

जावा मॉडल:

वास्तव में, मॉडल आयात करना इतना सरल नहीं है। नीचे हम कुछ बिंदुओं पर संक्षेप में प्रकाश डालेंगे जो कुछ मामलों में महत्वपूर्ण हो सकते हैं।

1) पैच सामान्यीकरण परत पुनरावर्ती परतों के बाद काम नहीं करती है। लगभग एक वर्ष [ 16 ] के लिए GitHub पर मुद्दा खुला है। उदाहरण के लिए, यदि आप इस परत को मॉडल (संपर्क परत के बाद) में जोड़ते हैं, तो हमें निम्नलिखित त्रुटि मिलती है:

 Exception in thread "main" java.lang.IllegalStateException: Invalid input type: Batch norm layer expected input of type CNN, CNN Flat or FF, got InputTypeRecurrent(160) for layer index -1, layer name = batch_normalization_1

व्यवहार में, मॉडल ने काम करने से इनकार कर दिया, एक समान त्रुटि का हवाला देते हुए जब सामान्यीकरण की परत को conv1d के बाद जोड़ा गया था। एक पूरी तरह से जुड़ी हुई परत के बाद, इसके अतिरिक्त त्रुटिपूर्ण रूप से काम करता है।

2) पूरी तरह से जुड़ी हुई परत के बाद, फ्लैटन परत को सेट करने से त्रुटि होती है। Stackoverflow [ 17 ] पर एक समान त्रुटि का उल्लेख किया गया है। छह महीने के लिए, कोई प्रतिक्रिया नहीं।

निश्चित रूप से यह सभी प्रतिबंध नहीं है जो आप DL4J के साथ काम करते समय मुठभेड़ कर सकते हैं।
मॉडल के लिए अंतिम परिचालन समय यहाँ है [ १ the]।

निष्कर्ष

अंत में, यह ध्यान दिया जा सकता है कि DL4J में दर्द रहित प्रशिक्षित केरस-मॉडल केवल साधारण मामलों के लिए ही संभव है (बेशक, अगर आपके पास ऐसा अनुभव नहीं है, और वास्तव में जावा का अच्छा ज्ञान है)।

कम उपयोगकर्ता परतें, मॉडल जितना अधिक दर्द रहित होगा आयात किया जाएगा, लेकिन अगर नेटवर्क आर्किटेक्चर जटिल है, तो आपको इसे DL4J में स्थानांतरित करने में बहुत समय बिताना होगा।

विकसित आयात मॉड्यूल का दस्तावेजी समर्थन, संबंधित उदाहरणों की संख्या, बल्कि नम लग रहा था। प्रत्येक चरण में, नए प्रश्न उठते हैं - लैम्ब्डा परतों को कैसे पंजीकृत किया जाए, मापदंडों का अर्थ, आदि।

तंत्रिका नेटवर्क आर्किटेक्चर की जटिलता और परतों के बीच बातचीत की गति, परत की जटिलता को देखते हुए, DL4J ने कृत्रिम तंत्रिका नेटवर्क के साथ काम करने के लिए शीर्ष-अंत चौखटे के स्तर तक पहुंचने के लिए अभी तक सक्रिय रूप से विकसित नहीं किया है।

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

संदर्भ

यदि आपके पास पायथन नहीं है, लेकिन एक केरस मॉडल और जावा है