उन लोगों के लिए, जो प्रयोग से डरते नहीं हैं, स्कैला पर मुस्कान के साथ एमएल

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

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

व्यवहार में, यह पता चला कि यह सब इतना आनंददायक नहीं था: कई पुस्तकालय नहीं हैं जो शास्त्रीय मशीन लर्निंग एल्गोरिदम को लागू करते हैं, और जो अक्सर बड़े विक्रेताओं के समर्थन के बिना ओपनसोर्स परियोजनाएं हैं। हां, ज़ाहिर है, स्पार्क एमएलआईबी है, लेकिन यह अपाचे हडोप पारिस्थितिकी तंत्र से दृढ़ता से जुड़ा हुआ है, और मैं वास्तव में इसे माइक्रोसैस आर्किटेक्चर में नहीं घसीटना चाहता था।

क्या जरूरत थी एक समाधान जो दुनिया को बचाएगा और एक आरामदायक नींद वापस लाएगा, और यह पाया गया था!

आपको क्या चाहिए?

जब हमने मशीन लर्निंग के लिए एक उपकरण चुना, तो हम निम्नलिखित मानदंडों से आगे बढ़े:

• यह सरल होना चाहिए;
  
• इसकी सादगी के बावजूद, किसी ने व्यापक कार्यक्षमता को रद्द नहीं किया है;
  
• मैं वास्तव में वेब-दुभाषिया में मॉडल विकसित करने में सक्षम होना चाहता था, और कंसोल या निरंतर विधानसभाओं और संकलनों के माध्यम से नहीं;
  
• प्रलेखन की उपलब्धता एक महत्वपूर्ण भूमिका निभाती है;
  
• आदर्श रूप से, कम से कम गीथूब मुद्दों का जवाब देने में समर्थन होगा।
  

हमने क्या देखा?

• अपाचे स्पार्क MLib : हमें सूट नहीं किया । जैसा कि ऊपर उल्लेख किया गया है, पुस्तकालयों का यह सेट अपाचे हडोप स्टैक और स्पार्क कोर से दृढ़ता से जुड़ा हुआ है, जो इसके आधार पर माइक्रोसर्विस बनाने के लिए बहुत अधिक वजन का है।
  
• Apache PredictionIO : एक दिलचस्प परियोजना, कई योगदानकर्ता, उदाहरण के साथ प्रलेखन है। वास्तव में, यह एक REST सर्वर है जिस पर मॉडल घूम रहे हैं। तैयार मॉडल हैं, उदाहरण के लिए, पाठ वर्गीकरण, जिसका प्रक्षेपण प्रलेखन में वर्णित है। प्रलेखन का वर्णन है कि आप अपने मॉडल को कैसे जोड़ और प्रशिक्षित कर सकते हैं। हम फिट नहीं थे, क्योंकि स्पार्क हुड के तहत उपयोग किया जाता है, और यह एक microservice वास्तुकला के बजाय एक अखंड समाधान के क्षेत्र से अधिक है।
  
• अपाचे एमएक्सनेट : तंत्रिका नेटवर्क के साथ काम करने के लिए एक दिलचस्प ढांचा, स्काला और पायथन के लिए समर्थन है - यह सुविधाजनक है, आप पायथन में एक तंत्रिका नेटवर्क को प्रशिक्षित कर सकते हैं, और फिर उत्पादन समाधान बनाते समय स्केल से सहेजे गए परिणाम को लोड कर सकते हैं। हम इसका उपयोग उत्पादन समाधान में करते हैं, यहां इस बारे में एक अलग लेख है ।
  
• स्माइल : अजगर के लिए स्किटिट-लर्न पैकेज के समान। क्लासिक मशीन लर्निंग एल्गोरिदम के कई कार्यान्वयन हैं, उदाहरणों के साथ अच्छा प्रलेखन, जीथब पर समर्थन, एक एकीकृत विज़ुअलाइज़र (स्विंग द्वारा संचालित), आप मॉडल विकसित करने के लिए जुपिटर नोटबुक का उपयोग कर सकते हैं। यह वही है जो आपको चाहिए!
  

पर्यावरण की तैयारी

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

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

#   BeakerX docker run -p 8888:8888 beakerx/beakerx 

लेकिन यहां पहली परेशानी इंतजार कर रही थी: लेख लिखने के समय, बीकरएक्स 1.0.0 को बीकरेक्स / बीकरैक्स छवि के अंदर स्थापित किया गया था, और संस्करण 1.4.1 पहले से ही परियोजना के आधिकारिक गितूब में उपलब्ध था (अधिक सटीक रूप से, नवीनतम रिलीज 1.3.0, लेकिन विज़ार्ड में 1.4.1 शामिल है, और यह काम करता है :-))।

यह स्पष्ट है कि मैं नवीनतम संस्करण के साथ काम करना चाहता हूं, इसलिए मैंने अपनी खुद की छवि BeakerX 1.4.1 पर आधारित है। मैं आपको डॉकरफाइल की सामग्री के साथ बोर नहीं करूंगा, यहां इसकी एक कड़ी है।

 #         mkdir -p /tmp/my_code docker run -it \ -p 8888:8888 \ -v /tmp/my_code:/workspace/my_code \ entony/jupyter-scala:1.4.1 

वैसे, जो लोग मेरी छवि का उपयोग करेंगे, उनके लिए एक छोटा सा बोनस होगा: उदाहरण निर्देशिका में प्लॉटिंग के साथ यादृच्छिक अनुक्रम के लिए एक उदाहरण के-साधन है (यह स्काला नोटबुक के लिए पूरी तरह से तुच्छ कार्य नहीं है)।

ज्यूपिटर नोटबुक में स्माइल डाउनलोड करें

बेहतरीन तैयार वातावरण! हम अपनी निर्देशिका में एक फ़ोल्डर में एक नई स्काला नोटबुक बनाते हैं, फिर हमें मावेन से पुस्तकालयों को काम करने के लिए डाउनलोड करने की आवश्यकता है;)।

 %%classpath add mvn com.github.haifengl smile-scala_2.12 1.5.2 

कोड निष्पादित करने के बाद, डाउनलोड की गई जार फ़ाइलों की एक सूची इसके आउटपुट ब्लॉक में दिखाई देगी।

अगला चरण: उदाहरण के लिए काम करने के लिए आवश्यक पैकेज आयात करना।

 import java.awt.image.BufferedImage import java.awt.Color import javax.imageio.ImageIO import java.io.File import smile.clustering._ 

क्लस्टरिंग के लिए डेटा तैयार करना

अब हम निम्नलिखित समस्या का समाधान करेंगे: तीन प्राथमिक रंगों के क्षेत्रों से मिलकर एक छवि बनाना - लाल, हरा और नीला (R, G, B)। चित्र में रंगों में से एक प्रबल होगा। हम छवि के पिक्सेल को क्लस्टर करते हैं, उस क्लस्टर को लेते हैं जिसमें सबसे अधिक पिक्सेल होंगे, उनके रंग को ग्रे में बदलें और सभी पिक्सेल से एक नई छवि का निर्माण करेंगे। अपेक्षित परिणाम: प्रमुख रंग का क्षेत्र भूरा हो जाएगा, शेष क्षेत्र अपना रंग नहीं बदलेगा।

 //    640  360 val width = 640 val hight = 360 //      val testImage = new BufferedImage(width, hight, BufferedImage.TYPE_INT_RGB) //   .    . for { x <- (0 until width) y <- (0 until hight) color = if (y <= hight / 3 && (x <= width / 3 || x > width / 3 * 2)) Color.RED else if (y > hight / 3 * 2 && (x <= width / 3 || x > width / 3 * 2)) Color.GREEN else Color.BLUE } testImage.setRGB(x, y, color.getRGB) //    testImage 

इस कोड को निष्पादित करने के परिणामस्वरूप, निम्न चित्र प्रदर्शित होता है:



अगला चरण: चित्र को पिक्सेल के एक सेट में परिवर्तित करें। पिक्सेल से हमारा मतलब निम्नलिखित गुणों वाली इकाई से है:

• विस्तृत पक्ष समन्वय (x);
  
• संकीर्ण पक्ष समन्वय (y);
  
• रंग मूल्य;
  
• वर्ग / क्लस्टर संख्या का वैकल्पिक मूल्य (क्लस्टरिंग पूरा होने से पहले, यह खाली होगा)।
  

एक इकाई के रूप में, case class का उपयोग करना सुविधाजनक है:

 case class Pixel(x: Int, y: Int, rgbArray: Array[Double], clusterNumber: Option[Int] = None) 

यहां, रंग मानों के लिए, लाल, हरे और नीले रंग के तीन मूल्यों के rgbArray सरणी का उपयोग किया जाता है (उदाहरण के लिए, लाल रंग Array(255.0, 0, 0) )।

 //      (Pixel) val pixels = for { x <- (0 until testImage.getWidth).toArray y <- (0 until testImage.getHeight) color = new Color(testImage.getRGB(x, y)) } yield Pixel(x, y, Array(color.getRed.toDouble, color.getGreen.toDouble, color.getBlue.toDouble)) //   10   pixels.take(10) 

यह डेटा तैयारी पूरी करता है।

पिक्सेल रंग क्लस्टरिंग

इसलिए, हमारे पास तीन प्राथमिक रंगों के पिक्सेल का संग्रह है, इसलिए हम पिक्सेल को तीन वर्गों में विभाजित करेंगे।

 //   val countColors = 3 //   val clusters = kmeans(pixels.map(_.rgbArray), k = countColors, runs = 20) 

प्रलेखन 10 से 20 की सीमा में runs पैरामीटर सेट करने की सिफारिश करता है।

जब इस कोड को निष्पादित किया जाता है, तो KMeans प्रकार का एक ऑब्जेक्ट बनाया जाएगा। आउटपुट ब्लॉक में क्लस्टरिंग के परिणामों की जानकारी होगी:

 K-Means distortion: 0.00000 Clusters of 230400 data points of dimension 3: 0 50813 (22.1%) 1 51667 (22.4%) 2 127920 (55.5%) 

एक क्लस्टर में बाकी की तुलना में अधिक पिक्सेल होते हैं। अब हमें 0 से 2 तक की कक्षाओं के साथ पिक्सेल के हमारे संग्रह को चिह्नित करने की आवश्यकता है।

 //    val clusteredPixels = (pixels zip clusters.getClusterLabel()).map {case (pixel, cluster) => pixel.copy(clusterNumber = Some(cluster))} //  10   clusteredPixels.take(10) 

निरंकुश छवि

केवल एक चीज बची हुई है, सबसे बड़ी संख्या में पिक्सेल के साथ क्लस्टर का चयन करना और इस क्लस्टर में शामिल सभी पिक्सेल को ग्रे ( rgbArray सरणी का मान बदलना)।

 //   val grayColor = Array(127.0, 127.0, 127.0) //       val blueClusterNumber = clusteredPixels.groupBy(pixel => pixel.clusterNumber) .map {case (clusterNumber, pixels) => (clusterNumber, pixels.size) } .maxBy(_._2)._1 //       val modifiedPixels = clusteredPixels.map { case p: Pixel if p.clusterNumber == blueClusterNumber => p.copy(rgbArray = grayColor) case p: Pixel => p } //  10      modifiedPixels.take(10) 

क्लस्टर नंबर द्वारा केवल समूह में कुछ भी जटिल नहीं है (यह हमारा Option:[Int] ), प्रत्येक समूह में तत्वों की संख्या की गणना करें और अधिकतम तत्वों के साथ क्लस्टर को बाहर निकालें। इसके बाद, रंग को केवल उन पिक्सल्स के लिए ग्रे में बदलें जो पाए गए क्लस्टर से संबंधित हैं।

एक नई छवि बनाएं और परिणाम सहेजें।

पिक्सेल संग्रह से एक नई छवि प्राप्त करना:

 //       val modifiedImage = new BufferedImage(width, hight, BufferedImage.TYPE_INT_RGB) //     modifiedPixels.foreach { case Pixel(x, y, rgbArray, _) => val r = rgbArray(0).toInt val g = rgbArray(1).toInt val b = rgbArray(2).toInt modifiedImage.setRGB(x, y, new Color(r, g, b).getRGB) } //    modifiedImage 

यही, आखिर में, हमने किया।



हम दोनों छवियों को बचाते हैं।

 ImageIO.write(testImage, "png", new File("testImage.png")) ImageIO.write(modifiedImage, "png", new File("modifiedImage.png")) 

निष्कर्ष

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

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

संदर्भ

• Scala Jupyter नोटबुक छवि के लिए Dockerfile: https://github.com/AntonYurchenko/docker/blob/master/jupyter-scala/Dockerfile
  
• एक उदाहरण के साथ गेट: https://github.com/AntonYurchenko/habr/tree/master/scala-smile-clustering
  
• अपाचे स्पार्क MLib: https://spark.apache.org/mllib
  
• Apache PredictionIO: http://predictionio.apache.org
  
• Apache MXNet: https://mxnet.incubator.apache.org
  
• मुस्कान: https://haifengl.imtqy.com/smile
  
• Git BeakerX: https://github.com/twosigma/beakerx