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

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

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

मैं तुरंत इस सवाल का जवाब देता हूं कि "पायथन में क्यों नहीं?": हम मल्टीथ्रेड कोड के अधिक सुविधाजनक और स्थिर लेखन के कारण उत्पादन समाधान के लिए स्काला का उपयोग करते हैं।

सामग्री

1. समस्या का विवरण
2. प्रौद्योगिकियों का इस्तेमाल किया
3. एक बुनियादी डॉकटर कंटेनर तैयार करना
4. परियोजना संरचना
5. तंत्रिका नेटवर्क लोड हो रहा है
6. रीस्ट एपीआई कार्यान्वयन
7. परीक्षण
8. एक बुनियादी छवि के आधार पर एक माइक्रोसैस सर्विस को असेंबल करना
9. एक GPU के साथ एक उत्पादन सर्वर पर एक microservice शुरू
निष्कर्ष
संदर्भ

1. समस्या का विवरण

मान लीजिए कि हमारे पास अलग-अलग ऑब्जेक्ट्स के साथ फ़ोटो का एक बड़ा डेटाबेस है, और हमें एक माइक्रोसॉफ़्ट बनाने की ज़रूरत है जो HTTP POST अनुरोध में एक तस्वीर प्राप्त करेगा और JSON प्रारूप में प्रतिक्रिया देगा। उत्तर में पाए जाने वाले ऑब्जेक्ट्स और उनकी कक्षाओं की संख्या, संभावना की डिग्री शामिल होनी चाहिए कि यह घोषित वर्ग की वस्तु है, और प्रत्येक ऑब्जेक्ट की सीमाओं को कवर करने वाले आयतों के निर्देशांक हैं।

2. प्रौद्योगिकियों का इस्तेमाल किया

• स्लाट 2.12.7 + अतिरिक्त पुस्तकालयों का न्यूनतम सेट, स्रोत कोड के निर्माण के लिए Sbt-पैक 0.12 प्लगइन के साथ Sbt 1.2.6।
• MXNet 1.3.1 (लेखन के समय नवीनतम स्थिर संस्करण), स्कला 2.12 के लिए संकलित।
• एनवीडिया ग्राफिक्स कार्ड के साथ सर्वर।
• Cuda 9.0 और Cudnn 7 सर्वर पर स्थापित है।
• संकलित कोड चलाने के लिए जावा 8।
• असेंबली की आसानी, वितरण और सर्वर पर माइक्रो सर्विस की शुरूआत।

3. एक बुनियादी डॉकटर कंटेनर तैयार करना

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

फ़ोल्डर संरचना:

\ | ----- install | | ----- java8.sh | | ----- mxnet_2_12.sh | | ----- opencv.sh | | ----- sbt.sh | | ----- scala.sh | | ----- timeZone.sh | ----- scala-mxnet-cuda-cudnn | ----- Dockerfile.2.12-1.3.1-9-7-builder | ----- Dockerfile.2.12-1.3.1-9-7-runtime 

Dockerfile.2.12-1.3.1-9-7-क्रम

इस छवि का उपयोग माइक्रोसेवा के अंतिम लॉन्च के लिए किया जाएगा। यह पूर्वनिर्मित CUDA 9.0 और CUDNN 7. के साथ Nvidia की आधिकारिक छवि पर आधारित है। MXNet 1.3.1 के लिए प्रलेखन CUDA 8.0 के साथ काम करने का दावा करता है, लेकिन, जैसा कि अभ्यास से पता चला है, सब कुछ 9.0 के साथ ठीक काम करता है 9.0 और यहां तक ​​कि थोड़ा तेज भी।

इसके अलावा, हम इस छवि में समय क्षेत्र स्थापित करने के लिए जावा 8, एमएक्सनेट 1.3.1 (हम इसे स्केला 2.12 के तहत बनाएंगे), ओपनसीवी 3.4.3 और लिनक्स-यूटिलिटी स्थापित करेंगे।

 #        Nvidia  cuda 9.0  cudnn 7 FROM nvidia/cuda:9.0-cudnn7-devel AS builder #    ENV MXNET_VERSION 1.3.1 ENV MXNET_BUILD_OPT "USE_OPENCV=1 USE_BLAS=openblas USE_CUDA=1 USE_CUDA_PATH=/usr/local/cuda USE_CUDNN=1" ENV CUDA_STUBS_DIR "/usr/local/cuda-9.0/targets/x86_64-linux/lib/stubs" ENV OPEN_CV_VERSION 3.4.3 ENV OPEN_CV_INSTALL_PREFIX /usr/local ENV JAVA_HOME /usr/lib/jvm/java-8-oracle/ ENV TIME_ZONE Europe/Moscow #     COPY install /install RUN chmod +x -R /install/* #   RUN apt-get update WORKDIR /install RUN ./timeZone.sh ${TIME_ZONE} RUN ./java8.sh RUN ./mxnet_2_12.sh ${MXNET_VERSION} "${MXNET_BUILD_OPT}" ${CUDA_STUBS_DIR} RUN ./opencv.sh ${OPEN_CV_VERSION} ${OPEN_CV_INSTALL_PREFIX} #     RUN apt-get autoclean -y && \ rm -rf /var/cache/* /install #       FROM nvidia/cuda:9.0-cudnn7-devel COPY --from=builder --chown=root:root / / 

स्क्रिप्ट टाइमजोन। एसश जावा 8. एस और ओपेनकेव। एस काफी तुच्छ हैं, इसलिए मैं उन पर विस्तार से ध्यान नहीं दूंगा, उन्हें नीचे प्रस्तुत किया गया है।

timeZone.sh

 #!/bin/sh #         TIME_ZONE=${1} #       apt-get install -y tzdata && \ ln -sf /usr/share/zoneinfo/$TIME_ZONE /etc/localtime && \ dpkg-reconfigure -f noninteractive tzdata 

java8.sh

 #!/bin/sh #  Java 8 apt-get install -y software-properties-common && \ add-apt-repository ppa:webupd8team/java -y && \ apt-get update && \ echo "oracle-java8-installer shared/accepted-oracle-license-v1-1 select true" | debconf-set-selections && \ apt-get install -y oracle-java8-installer 

opencv.sh

 #!/bin/sh #   OpenCV     OPEN_CV_VERSION=${1} #        OPEN_CV_INSTALL_PREFIX=${2} OPEN_CV_TAR="http://github.com/opencv/opencv/archive/${OPEN_CV_VERSION}.tar.gz" #  OpenCV apt-get install -y wget build-essential cmake && \ wget -qO- ${OPEN_CV_TAR} | tar xzv -C /tmp && \ mkdir /tmp/opencv-${OPEN_CV_VERSION}/build && \ cd /tmp/opencv-${OPEN_CV_VERSION}/build && \ cmake -DBUILD_JAVA=ON -DCMAKE_INSTALL_PREFIX:PATH=${OPEN_CV_INSTALL_PREFIX} .. && \ make -j$((`nproc`+1)) && \ make install && \ rm -rf /tmp/opencv-${OPEN_CV_VERSION} 

MXNet स्थापित करना इतना सरल नहीं है। तथ्य यह है कि स्काला के लिए इस लाइब्रेरी की सभी असेंबलियों को कंपाइलर संस्करण 2.11 के आधार पर बनाया गया है, और यह उचित है, क्योंकि लाइब्रेरी में स्पार्क के साथ काम करने के लिए एक मॉड्यूल शामिल है, जो बदले में, स्कला 2.11 में लिखा गया है। यह ध्यान में रखते हुए कि हम विकास में Scala 2.12.7 का उपयोग करते हैं, संकलित पुस्तकालय हमारे लिए उपयुक्त नहीं हैं, और हम संस्करण 2.11 पर नीचे नहीं जा सकते। * नए स्काला संस्करण पर पहले से ही लिखे गए कोड की बड़ी मात्रा के कारण, हम नहीं कर सकते। क्या करें? स्काला के हमारे संस्करण के लिए स्रोत से MXNet एकत्र करने में बहुत मज़ा आता है। नीचे मैं Scala 2.12 के लिए MXNet 1.3.1 बनाने और स्थापित करने के लिए एक स्क्रिप्ट दूंगा। * और मुख्य बिंदुओं पर टिप्पणी करें।

mxnet_2_12.sh

 #!/bin/sh #   MXNet     MXNET_VERSION=${1} #     ++  MXNet     MXNET_BUILD_OPT=${2} #       CUDA     CUDA_STUBS_DIR=${3} LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${CUDA_STUBS_DIR}" #       MXNet   apt-get install -y git build-essential libopenblas-dev libopencv-dev maven cmake && \ git clone -b ${MXNET_VERSION} --recursive https://github.com/dmlc/mxnet /tmp/mxnet && \ cd /tmp/mxnet && \ make -j $(nproc) ${MXNET_BUILD_OPT} && \ ln -s ${CUDA_STUBS_DIR}/libcuda.so ${CUDA_STUBS_DIR}/libcuda.so.1 && \ sed -rim 's/([a-zA-Z])_2.11/\1_2.12/g' $(find scala-package -name pom.xml) && \ sed -im 's/SCALA_VERSION_PROFILE := scala-2.11/SCALA_VERSION_PROFILE := scala-2.12/g' Makefile && \ sed -im 's/<module>spark<\/module>/<\!--<module>spark<\/module>-->/g' scala-package/pom.xml && \ make scalapkg ${MXNET_BUILD_OPT} && \ mkdir -p /usr/local/share/mxnet/scala/linux-x86_64-gpu && \ mv /tmp/mxnet/scala-package/assembly/linux-x86_64-gpu/target/mxnet-full_2.12-linux-x86_64-gpu-${MXNET_VERSION}-SNAPSHOT.jar /usr/local/share/mxnet/scala/linux-x86_64-gpu/mxnet-full_2.12-linux-x86_64-gpu-${MXNET_VERSION}-SNAPSHOT.jar && \ rm -rf /tmp/mxnet && rm -rf /root/.m2 

सबसे दिलचस्प हिस्सा इस लाइन से शुरू होता है:

 ln -s ${CUDA_STUBS_DIR}/libcuda.so ${CUDA_STUBS_DIR}/libcuda.so.1 && \ 

यदि आप निर्देशों के अनुसार MXNet असेंबली चलाते हैं, तो हमें एक त्रुटि मिलेगी। संकलक को libcuda.so.1 लाइब्रेरी नहीं मिल सकती है, इसलिए हम libcuda.so लाइब्रेरी से libcuda.so.1 से लिंक करेंगे। यह आपको परेशान नहीं कर सकता है, जब आप इसे एक उत्पादन सर्वर पर शुरू करते हैं, तो हम इस लाइब्रेरी को एक स्थानीय के साथ बदल देंगे। यह भी ध्यान दें कि CUDA_STUBS_DIR पर्यावरण चर से CUDA पुस्तकालयों का मार्ग LD_LIBRARY_PATH में जोड़ा गया है। अगर ऐसा नहीं किया गया, तो विधानसभा भी विफल हो जाएगी।

इन पंक्तियों में, हम नियमित अभिव्यक्ति का उपयोग करके सभी आवश्यक फ़ाइलों में 2.12 के साथ Scala 2.11 के संस्करण को प्रतिस्थापित करते हैं, जिसे प्रयोगात्मक रूप से चुना गया था, क्योंकि यह 2.12 के साथ हर जगह 2.11 को बदलने के लिए पर्याप्त नहीं है:

 sed -rim 's/([a-zA-Z])_2.11/\1_2.12/g' $(find scala-package -name pom.xml) && \ sed -im 's/SCALA_VERSION_PROFILE := scala-2.11/SCALA_VERSION_PROFILE := scala-2.12/g' Makefile && \ sed -im 's/<module>spark<\/module>/<\!--<module>spark<\/module>-->/g' scala-package/pom.xml && \ make scalapkg ${MXNET_BUILD_OPT} && \ 

और फिर स्पार्क के साथ काम करने के लिए मॉड्यूल पर निर्भरता पर टिप्पणी की जाती है। यदि ऐसा नहीं किया जाता है, तो पुस्तकालय को इकट्ठा नहीं किया जाएगा।

अगला, असेंबली चलाएं, जैसा कि निर्देशों में संकेत दिया गया है, इकट्ठे पुस्तकालय को एक साझा फ़ोल्डर में कॉपी करें और निर्माण प्रक्रिया के दौरान मावेन पंप किए गए कचरे को हटा दें (यदि ऐसा नहीं किया जाता है, तो अंतिम छवि लगभग 3-4 जीबी बढ़ जाएगी, जो आपके DevOps का कारण बन सकती है) नर्वस)।

हम परियोजना के मूल निर्देशिका में होने के नाते, छवि को इकट्ठा करते हैं (देखें। फ़ोल्डर संरचना):

 your@pc$ docker build -f Dockerfile.2.12-1.3.1-9-7-runtime -t entony/scala-mxnet-cuda-cudnn:2.12-1.3.1-9-7-runtime . 

मुझे केवल आपको याद दिलाना चाहिए कि अंत में डॉट कहता है कि हम वर्तमान निर्देशिका के संदर्भ में असेंबली कर रहे हैं।

अब बिल्ड इमेज के बारे में बात करने का समय आ गया है।

Dockerfile.2.12-1.3.1-9-7 निर्माता

 #         runtime-,    FROM entony/scala-mxnet-cuda-cudnn:2.12-1.3.1-9-7-runtime #    ENV SCALA_VERSION 2.12.7 ENV SBT_VERSION 1.2.6 #     COPY install /install RUN chmod +x -R /install/* #       RUN apt-get update && \ cd /install && \ ./scala.sh ${SCALA_VERSION} && \ ./sbt.sh ${SBT_VERSION} #   RUN rm -rf /install 

यह सरल है, हमें अपने माइक्रोसेवा को शुरू करने के लिए स्काला और एसबीटी की आवश्यकता नहीं है, इसलिए उन्हें लॉन्च के लिए आधार छवि में खींचने का कोई मतलब नहीं है। इसलिए, हम एक अलग छवि बनाएंगे जिसका उपयोग केवल विधानसभा के लिए किया जाएगा। Scala.sh और sbt.sh स्क्रिप्ट काफी तुच्छ हैं और मैं उन पर विस्तार से ध्यान नहीं दूंगा।

scala.sh

 #!/bin/sh #   Scala     SCALA_VERSION=${1} SCALA_DEB="http://www.scala-lang.org/files/archive/scala-${SCALA_VERSION}.deb" #  Scala apt-get install -y wget && \ wget -q ${SCALA_DEB} -O /tmp/scala.deb && dpkg -i /tmp/scala.deb && \ scala -version && \ rm /tmp/scala.deb 

sbt.sh

 #!/bin/sh #   Sbt     SBT_VERSION=${1} SBT_DEB="http://dl.bintray.com/sbt/debian/sbt-${SBT_VERSION}.deb" #  Sbt apt-get install -y wget && \ wget -q ${SBT_DEB} -O /tmp/sbt.deb && dpkg -i /tmp/sbt.deb && \ sbt sbtVersion && \ rm /tmp/sbt.deb 

हम परियोजना के मूल निर्देशिका में होने के नाते, छवि को इकट्ठा करते हैं (देखें। फ़ोल्डर संरचना):

 your@pc$ docker build -f Dockerfile.2.12-1.3.1-9-7-builder -t entony/scala-mxnet-cuda-cudnn:2.12-1.3.1-9-7-builder . 

लेख के अंत में इन सभी फाइलों के साथ रिपॉजिटरी के लिंक हैं।

4. परियोजना संरचना

प्रोजेक्ट की असेंबली की तैयारी पूरी करने के बाद, आपने इस लेख के लिए समय बिताने का फैसला किया।

हमारे microservice की परियोजना में निम्नलिखित संरचना होगी:

 \ | ----- dependencies | | ----- mxnet-full_2.12-linux-x86_64-gpu-1.3.1-SNAPSHOT.jar | ----- models | | ----- resnet50_ssd_model-0000.params | | ----- resnet50_ssd_model-symbol.json | | ----- synset.txt | ----- project | | ----- build.properties | | ----- plugins.sbt | ----- src | | ----- main | | | ----- resources | | | | ----- cat_and_dog.jpg | | | ----- scala | | | | ----- simple.predictor | | | | ----- Config | | | | ----- Model | | | | ----- Server | | | | ----- Run | | ----- test | | | ----- scala | | | | ----- simple.predictor | | | | ----- ServerTest | ----- build.sbt | ----- Dockerfile 

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

• एमएक्सनेट का निर्माण उस मशीन पर करें जहां आप विकास कर रहे हैं (ध्यान दें कि लाइब्रेरी क्रॉस-प्लेटफॉर्म नहीं है; यदि आप इसे लिनक्स पर बनाते हैं, तो यह मैक ओएस पर काम नहीं करेगा);
• या उस डॉकरी छवि से बाहर खींचो जिसे हमने पहले बनाया था। यदि आप एक स्थानीय वातावरण में एमएक्सनेट का निर्माण करने का निर्णय लेते हैं, तो mxnet_2.12.sh स्क्रिप्ट आपकी मदद करेगी।

आप इस तरह से डॉकर छवि से पुस्तकालयों को बाहर निकाल सकते हैं:

 #   your@pc$ mkdir dependencies #  Docker-    your@pc$ docker run -it --rm -v $(pwd)/dependencies:/tmp/dependencies entony/scala-mxnet-cuda-cudnn:2.12-1.3.1-9-7-runtime #          ab38e73d93@root$ cp /usr/local/share/mxnet/scala/linux-x86_64-gpu/mxnet-full_2.12-linux-x86_64-gpu-1.3.1-SNAPSHOT.jar /tmp/dependencies/mxnet-full_2.12-linux-x86_64-gpu-1.3.1-SNAPSHOT.jar ab38e73d93@root$ exit #  , ! your@pc$ ls dependencies/ mxnet-full_2.12-linux-x86_64-gpu-1.3.1-SNAPSHOT.jar -SNAPSHOT.jar #   your@pc$ mkdir dependencies #  Docker-    your@pc$ docker run -it --rm -v $(pwd)/dependencies:/tmp/dependencies entony/scala-mxnet-cuda-cudnn:2.12-1.3.1-9-7-runtime #          ab38e73d93@root$ cp /usr/local/share/mxnet/scala/linux-x86_64-gpu/mxnet-full_2.12-linux-x86_64-gpu-1.3.1-SNAPSHOT.jar /tmp/dependencies/mxnet-full_2.12-linux-x86_64-gpu-1.3.1-SNAPSHOT.jar ab38e73d93@root$ exit #  , ! your@pc$ ls dependencies/ mxnet-full_2.12-linux-x86_64-gpu-1.3.1-SNAPSHOT.jar 

मॉडल निर्देशिका में एक प्रशिक्षित तंत्रिका नेटवर्क की फाइलें हैं, आप उन्हें निम्नानुसार स्वतंत्र रूप से डाउनलोड कर सकते हैं:

 #   your@pc$ mkdir models #     your@pc$ wget https://s3.amazonaws.com/model-server/models/resnet50_ssd/resnet50_ssd_model-symbol.json -P models your@pc$ wget https://s3.amazonaws.com/model-server/models/resnet50_ssd/resnet50_ssd_model-0000.params -P models your@pc$ wget https://s3.amazonaws.com/model-server/models/resnet50_ssd/synset.txt -P models 

आगे उन फ़ाइलों के बारे में संक्षेप में बताया गया है जो विशेष रुचि के नहीं हैं, लेकिन परियोजना में भूमिका निभाते हैं।

परियोजना / build.properties

 #   Sbt,   sbt.version = 1.2.6 

प्रोजेक्ट / plugins.sbt

 //    sbt-pack addSbtPlugin("org.xerial.sbt" % "sbt-pack" % "0.12") 

src / main / Resources / cat_and_dog.jpg

ऐसी अद्भुत तस्वीर, जिसमें हमारा तंत्रिका नेटवर्क एक बिल्ली और एक कुत्ते की तलाश में होगा।

build.sbt

 enablePlugins(PackPlugin) name := "simple-predictor" version := "0.1" scalaVersion := "2.12.7" unmanagedBase := baseDirectory.value / "dependencies" //  (   ) libraryDependencies ++= Seq( "org.json4s" %% "json4s-native" % "3.6.1", "org.scalatest" %% "scalatest" % "3.0.5" % Test, "org.scalaj" %% "scalaj-http" % "2.4.1" % Test ) //       packMain := Map("simple-predictor" -> "simple.predictor.Runs") //    bat-,      ,   Linux packGenerateWindowsBatFile := false //    JVM packJvmOpts := Map("simple-predictor" -> Seq( "-Xms3g", "-Xmx5g")) 

simple.predictor.Config

यह ऑब्जेक्ट वैश्विक चर को संग्रहीत करता है जिसका मान पर्यावरण चर से पढ़ा जाता है या डिफ़ॉल्ट रूप से सेट किया जाता है।

 package simple.predictor import org.apache.mxnet.Context import scala.util.Try object Config { //    REST API val host: String = env("REST_HOST") getOrElse "0.0.0.0" //    REST API val port: Int = env("REST_PORT") flatMap (p => Try(p.toInt).toOption) getOrElse 8080 // URL,     POST-   val entryPoint: String = env("REST_ENTRY_POINT") getOrElse "/predict" //  ,       val threshold: Float = env("PROBABILITY_MORE") flatMap (p => Try(p.toFloat).toOption) getOrElse 0.5f //        val modelPrefix: String = env("MODEL_PREFIX") getOrElse "models/resnet50_ssd_model" //    (    ...-0000.params) val modemEpoch: Int = env("MODEL_EPOCH") flatMap (p => Try(p.toInt).toOption) getOrElse 0 //   ,     ,    512 val modemEdge: Int = env("MODEL_EDGE") flatMap (p => Try(p.toInt).toOption) getOrElse 512 //  ,   CPU ( ).  production  GPU val context: Context = env("MODEL_CONTEXT_GPU") flatMap { isGpu => Try(if (isGpu.toBoolean) Context.gpu() else Context.cpu()).toOption } getOrElse Context.cpu() private def env(name: String) = Option(System.getenv(name)) } 

simple.predictor.Run

रन ऑब्जेक्ट एप्लिकेशन के लिए प्रवेश बिंदु है।

 package simple.predictor import java.net.InetSocketAddress //     import simple.predictor.Config._ object Run extends App { //     REST- val model = new Model(modelPrefix, modemEpoch, modemEdge, threshold, context) val server = new Server(new InetSocketAddress(host, port), entryPoint, model) //   Ctrl + C    Runtime.getRuntime.addShutdownHook(new Thread(() => server.stop())) //      try server.start() catch { case ex: Exception => ex.printStackTrace() } } 

5. तंत्रिका नेटवर्क लोड हो रहा है

तंत्रिका नेटवर्क को simple.predictor.Model वर्ग के कंस्ट्रक्टर में लोड किया जाता है।

simple.predictor.Model

 package simple.predictor import java.awt.image.BufferedImage import org.apache.mxnet._ import org.apache.mxnet.infer.ObjectDetector import simple.predictor.Model.Prediction class Model(prefix: String, epoch: Int, imageEdge: Int, threshold: Float, context: Context) { //       val initShape = Shape(1, 3, imageEdge, imageEdge) val initData = DataDesc(name = "data", initShape, DType.Float32, Layout.NCHW) //           val model = new ObjectDetector(prefix, IndexedSeq(initData), context, Option(epoch)) //         ,       JSON private def toPrediction(originWidth: Int, originHeight: Int)(predict: (String, Array[Float])): Prediction = { val (objectClass, Array(probability, kx, ky, kw, kh)) = predict //        val x = (originWidth * kx).toInt val y = (originHeight * ky).toInt val w = (originWidth * kw).toInt val h = (originHeight * kh).toInt val width = if ((x + w) < originWidth) w else originWidth - x val height = if (y + h < originHeight) h else originHeight - y Prediction(objectClass, probability, x, y, width, height) } //     ,         ,     threshold def predict(image: BufferedImage): Seq[Prediction] = model.imageObjectDetect(image).head map toPrediction(image.getWidth, image.getHeight) filter (_.probability > threshold) } object Model { //   case class Prediction(objectClass: String, probability: Float, x: Int, y: Int, width: Int, height: Int) } 

करने वाले अनुभाग में आप कहते हैं कि तंत्रिका नेटवर्क में यह 1 x 3 x 512 x 512 के आयाम के साथ NDArray साथ काम करेगा, जहाँ 1 NDARray में निहित छवियों की संख्या, 3 रंगों की संख्या और 512 x 512 है - छवि का आकार ( imageEdge = 12 का मान simple.predict.Config ऑब्जेक्ट में सेट है, यह न्यूरल नेटवर्क को प्रशिक्षित करने के लिए उपयोग की जाने वाली छवि का साइड आकार है)। यह सारा डेटा विवरण ObjectDetector को दिया जाता है।

एक और दिलचस्प खंड की ।

तंत्रिका नेटवर्क के माध्यम से छवि को चलाने के बाद, परिणाम Seq[Seq[(String, Array[Float])]] । पहले संग्रह में केवल एक परिणाम होता है (डेटा प्रारूप एक विशिष्ट तंत्रिका नेटवर्क द्वारा निर्धारित किया जाता है), फिर अगले संग्रह का प्रत्येक तत्व दो तत्वों का एक समूह है:

1. वर्ग नाम ("बिल्ली", "कुत्ता", ...),
2. पाँच फ़्लोटिंग पॉइंट नंबरों की एक सरणी: पहली संभावना है, दूसरी x निर्देशांक की गणना के लिए गुणांक है, तीसरी y समन्वय की गणना के लिए गुणांक है, चौथा आयत चौड़ाई की गणना के लिए गुणांक है, और पाँचवाँ आयत की ऊँचाई की गणना करने के लिए गुणांक है।

आयत के वास्तविक निर्देशांक और आकार प्राप्त करने के लिए, आपको संबंधित गुणांकों द्वारा छवि की मूल चौड़ाई और ऊंचाई को गुणा करना होगा।
मैं NDArray के विषय पर खुद को थोड़ा विषयांतर करने की अनुमति देता हूं। यह एक बहुआयामी सरणी है जिसे MXNet किसी दिए गए संदर्भ (CPU या GPU) में बनाता है। NDArray बनाते समय, C ++ ऑब्जेक्ट बनता है, एक ऑब्जेक्ट जिसके साथ ऑपरेशन बहुत तेज़ी से किया जाता है (और अगर यह GPU संदर्भ में बनाया गया है, तो यह लगभग तात्कालिक है), लेकिन आपको ऐसी गति के लिए भुगतान करना होगा। परिणामस्वरूप (कम से कम संस्करण एमएक्सनेट 1.3.1 में) आपको NDArray लिए आवंटित मेमोरी को स्वतंत्र रूप से प्रबंधित करने की आवश्यकता है, और आप उनके साथ काम करने के बाद इन ऑब्जेक्ट्स को मेमोरी से अनलोड करना न भूलें। अन्यथा, एक महत्वपूर्ण और काफी तेज मेमोरी रिसाव होगा, जो मॉनिटर करने के लिए बहुत सुविधाजनक नहीं है, क्योंकि जेवीएम प्रोफाइलिंग के कार्यक्रम इसे नहीं देखते हैं। यदि आप GPU संदर्भ में काम करते हैं, तो मेमोरी की समस्या बढ़ जाती है, क्योंकि वीडियो कार्ड में बड़ी मात्रा में मेमोरी नहीं होती है और एप्लिकेशन मेमोरी से जल्दी क्रैश हो जाता है।

मेमोरी लीक की समस्या को कैसे हल करें?

उपर्युक्त उदाहरण में, लाइन model.imageObjectDetect(image).head map toPrediction(image.getWidth, image.getHeight) filter (_.probability > threshold) , imageObjectDetect विधि का उपयोग तंत्रिका नेटवर्क के माध्यम से छवि को चलाने के लिए किया जाता है, जो एक BufferedImage इनपुट प्राप्त करता है। NDArray से सभी रूपांतरण विधि के अंदर किए NDArray हैं, और आपको मेमोरी डीलॉक्लेशन समस्याओं के बारे में सोचने की आवश्यकता नहीं है। दूसरी ओर, NDArray को NDArray परिवर्तित करने से पहले NDArray का कार्य 512 x 512 के NDArray में किया जाता है और छवि को NDArray ऑब्जेक्ट के तरीकों का उपयोग करके सामान्यीकृत किया जाता है। उदाहरण के लिए, OpenCV का उपयोग करने की तुलना में यह थोड़ा लंबा होता है, लेकिन यह NDArray का उपयोग करने के बाद मेमोरी को मुक्त करने की समस्या को हल करता है।

आप निश्चित रूप से OpenCV का उपयोग कर सकते हैं और मेमोरी को स्वयं नियंत्रित कर सकते हैं, इसके लिए आपको बस dispose की dispose विधि को कॉल करने की dispose , लेकिन किसी कारण से आप स्काला के लिए आधिकारिक MXNet दस्तावेज में इसका उल्लेख करना भूल गए।

MXNet के पास NDArray के कारण होने वाली मेमोरी लीक को नियंत्रित करने का एक सुविधाजनक तरीका नहीं है। ऐसा करने के लिए, JVM पैरामीटर Dmxnet.traceLeakedObjects=true साथ एप्लिकेशन चलाएँ। यदि एमएक्सनेट एक एनडीएआरईआर नोटिस करता है जो उपयोग में नहीं है, लेकिन स्मृति में लटका हुआ है, तो आपको एक अपवाद मिलेगा जो यह संकेत देगा कि किस लाइन का कोड गलत NDArray ।

मेरी सलाह: NDArray के साथ सीधे काम करें, ध्यान से मेमोरी की निगरानी करें और अपने आप को सामान्यीकरण लिखें, पहले निर्दिष्ट करें कि तंत्रिका इंजीनियर को प्रशिक्षित करते समय एमएल इंजीनियर ने क्या किया, अन्यथा परिणाम पूरी तरह से अलग होंगे। ObjectDetector में एक objectDetectWithNDArray विधि है जिससे आप NDArray पास कर सकते हैं। तंत्रिका नेटवर्क को लोड करने के लिए अधिक सार्वभौमिक दृष्टिकोण को लागू करने के लिए, मैं org.apache.mxnet.module.Module ऑब्जेक्ट का उपयोग करने की सलाह देता हूं। नीचे उपयोग का एक उदाहरण है।

 import org.apache.mxnet._ import org.apache.mxnet.io.NDArrayIter //      val model: Module = { val model = Module.loadCheckpoint(modelPrefix, modelEpoch, contexts = contexts) model.bind( forTraining = false, inputsNeedGrad = false, forceRebind = false, dataShape = DataDesc(name = "data", Shape(1, 3, 512, 512), DType.Float32, Layout.NCHW)) model.initParams() model } // NDArray  1  3  512  512 val image: NDArray = ??? //  dataBatch      val iterator = new NDArrayIter(IndexedSeq(image)) val dataBatch = iterator.next() image.dispose() //   val result: Seq[Array[Float]] = model.predict(dataBatch) map { ndArray => val array = ndArray.toArray ndArray.dispose() array } dataBatch.dispose() 

6. रीस्ट एपीआई कार्यान्वयन

REST API को लागू करने के लिए simple.predictor.Server वर्ग जिम्मेदार है। सर्वर जावा में शामिल जावा सर्वर पर आधारित है।

simple.predictor.Server

 package simple.predictor import java.net.InetSocketAddress import com.sun.net.httpserver.{HttpExchange, HttpServer} import javax.imageio.ImageIO import org.json4s.DefaultFormats import org.json4s.native.Serialization class Server(address: InetSocketAddress, entryPoint: String, model: Model) { //   HTTP-,     java private val server = HttpServer.create(address, 0) //      URL server.createContext(entryPoint, (http: HttpExchange) => { //   HTTP-     val header = http.getRequestHeaders val (httpCode, json) = if (header.containsKey("Content-Type") && header.getFirst("Content-Type") == "image/jpeg") { //          ,      200 val image = ImageIO.read(http.getRequestBody) val predictionSeq = model.predict(image) (200, Map("prediction" -> predictionSeq)) } else (400, Map("error" -> "Invalid content")) //       400 //    JSON    val responseJson = Serialization.write(json)(DefaultFormats) val httpOs = http.getResponseBody http.getResponseHeaders.set("Content-Type", "application/json") http.sendResponseHeaders(httpCode, responseJson.length) httpOs.write(responseJson.getBytes) httpOs.close() }) def start(): Unit = server.start() def stop(): Unit = server.stop(0) } 

7. परीक्षण

जाँच करने के लिए, सर्वर शुरू करें और एक परीक्षण चित्र भेजें src / main / Resources / cat_and_dog.jpg। हम सर्वर से प्राप्त JSON को पार्स करेंगे, चित्र में तंत्रिका नेटवर्क को कितनी और किन वस्तुओं को मिलाएं, और चित्र में वस्तुओं को सर्कल करें।

simple.predictor.ServerTest

 package simple.predictor import java.awt.{BasicStroke, Color, Font} import java.awt.image.BufferedImage import java.io.{ByteArrayOutputStream, File} import java.net.InetSocketAddress import javax.imageio.ImageIO import org.scalatest.{FlatSpec, Matchers} import scalaj.http.Http import org.json4s.{DefaultFormats, Formats} import org.json4s.native.JsonMethods.parse import simple.predictor.Config._ import simple.predictor.Model.Prediction import scala.concurrent.Future import scala.concurrent.ExecutionContext.Implicits.global class ServerTest extends FlatSpec with Matchers { implicit val formats: Formats = DefaultFormats "Service" should "find a cat and a dog on photo" in { //      val model = new Model(modelPrefix, modemEpoch, modemEdge, threshold, context) val server = new Server(new InetSocketAddress(host, port), entryPoint, model) //      Future(server.start()) Thread.sleep(5000) //         val image = ImageIO.read(getClass.getResourceAsStream("/cat_and_dog.jpg")) val byteOS = new ByteArrayOutputStream() ImageIO.write(image, "jpg", byteOS) val data = byteOS.toByteArray //      ,     200 val response = Http(s"http://$host:$port$entryPoint").header("Content-Type", "image/jpeg").postData(data).asString response.code shouldEqual 200 //  JSON-, ,       val prediction = parse(response.body) \\ "prediction" prediction.children.size shouldEqual 2 //     , ,     ,    val objectClassList = (prediction \\ "objectClass").children map (_.extract[String]) objectClassList.head shouldEqual "cat" objectClassList.tail.head shouldEqual "dog" //   ,   val bBoxCoordinates = prediction.children.map(_.extract[Prediction]) //   ,     val imageWithBoundaryBoxes = new BufferedImage(image.getWidth, image.getHeight, image.getType) val graph = imageWithBoundaryBoxes.createGraphics() graph.drawImage(image, 0, 0, null) graph.setColor(Color.RED) graph.setStroke(new BasicStroke(5)) graph.setFont(new Font(Font.SANS_SERIF, Font.TRUETYPE_FONT, 30)) bBoxCoordinates foreach { case Prediction(obj, prob, x, y, width, height) => graph.drawRect(x, y, width, height) graph.drawString(s"$obj, prob: $prob", x + 15, y + 30) } graph.dispose() //         ImageIO.write(imageWithBoundaryBoxes, "jpg", new File("./test.jpg")) } } 

, .

8.

, . Docker , .

Dockerfile

 #       Sbt FROM entony/scala-mxnet-cuda-cudnn:2.12-1.3.1-9-7-builder AS builder #       RUN mkdir /tmp/source /tmp/source/dependencies COPY project /tmp/source/project COPY src /tmp/source/src COPY build.sbt /tmp/source/build.sbt #     MXNet,       RUN ln -s /usr/local/share/mxnet/scala/linux-x86_64-gpu/mxnet-full_2.12-linux-x86_64-gpu-1.3.1-SNAPSHOT.jar /tmp/source/dependencies/mxnet-full_2.12-linux-x86_64-gpu-1.3.1-SNAPSHOT.jar && \ cd /tmp/source/ && sbt pack #      FROM entony/scala-mxnet-cuda-cudnn:2.12-1.3.1-9-7-runtime #   LD   Cuda   Java ENV LD_LIBRARY_PATH /usr/local/cuda-9.0/targets/x86_64-linux/lib/stubs:/usr/local/share/OpenCV/java #            /opt/app/models ENV MODEL_PREFIX "/opt/app/models/resnet50_ssd_model" #            RUN mkdir -p /opt/app COPY --from=builder --chown=root:root /tmp/source/target/pack /opt/app COPY models /opt/app/models #      ENTRYPOINT /opt/app/bin/simple-predictor 

 # ,    ,   Dockerfile your@pc$ docker build -f Dockerfile -t entony/simple-predictor:1.0.0 . #   docker hub your@pc$ docker push entony/simple-predictor:1.0.0 

9. production- GPU

, docker hub, Nvidia, 8080 Docker, Cuda 9.0 Cudnn 7.

 #     Docker hub your@server-with-gpu$ docker pull entony/simple-predictor:1.0.0 #     your@server-with-gpu$ docker run -d \ -p 8080:8080 \ -e MODEL_CONTEXT_GPU=true \ -e MXNET_CUDNN_AUTOTUNE_DEFAULT=0 \ --name 'simple_predictor' \ --device /dev/nvidia0:/dev/nvidia0 \ --device /dev/nvidiactl:/dev/nvidiactl \ --device /dev/nvidia-uvm:/dev/nvidia-uvm \ -v /usr/lib/x86_64-linux-gnu/libcuda.so.1:/usr/local/cuda-9.0/targets/x86_64-linux/lib/stubs/libcuda.so.1:ro \ -v /usr/lib/nvidia-396/libnvidia-fatbinaryloader.so.396.54:/usr/local/cuda-9.0/targets/x86_64-linux/lib/stubs/libnvidia-fatbinaryloader.so.396.54:ro \ entony/simple-predictor:1.0.0 

Docker- --device Cuda- -v .

MODEL_CONTEXT_GPU GPU-, MXNET_CUDNN_AUTOTUNE_DEFAULT ( , , , ).

:

 #  your@server-with-gpu$ curl -X POST -H 'Content-Type: image/jpeg' --data-binary '@src/main/resources/cat_and_dog.jpg' http://0.0.0.0:8080/predict #  { "prediction":[ { "objectClass":"cat", "probability":0.9959417, "x":72,"y":439, "width":950, "height":987 }, { "objectClass":"dog", "probability":0.81277525, "x":966, "y":100, "width":870, "height":1326 } ] } 

निष्कर्ष

MXNet , - . , , , production.

, , MXNet , Python production Scala, Java ++.

, .

, . . आपका ध्यान के लिए धन्यवाद।

संदर्भ

• Git Docker-
• Git
• MXNet