Microsoft ML स्पार्क: एक स्पार्क एक्सटेंशन जो स्पार्कलएम को अधिक मानवीय बनाता है और लाइट जीबीएम एक बोनस के रूप में

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

और ऐसा लगता है कि अब, MMLSpark लाइब्रेरी के साथ, जीवन थोड़ा आसान हो जाएगा, और स्पार्कएमएल और स्काला के साथ स्केलेबल मशीन सीखने में प्रवेश करने की सीमा थोड़ी कम है।

परिचय

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

आज हम MMLSpark लाइब्रेरी को देखते हैं ।

हम हमेशा की तरह, टाइटैनिक के यात्रियों को वर्गीकृत करने के कार्य के उदाहरण पर विचार करेंगे। लक्ष्य संभव के रूप में MMLSpark पुस्तकालय की कई विशेषताओं को दिखाने के लिए है, नहीं छवि पर SOTA बाहर दस्तक कूल मशीन लर्निंग दिखाओ। तो टाइटैनिक करेंगे।

लाइब्रेरी में ही स्काला ( प्रलेखन ), पायथन एपीआई ( प्रलेखन ) के लिए एक देशी एपीआई है, और, GitHub रिपॉजिटरी में कुछ स्थानों को देखते हुए, यह जल्द ही आर के लिए एक एपीआई होगा।

GitHub प्रोजेक्ट (PySpark + Jupyter) में अच्छे उदाहरण वाले लैपटॉप हैं , लेकिन हम दूसरे रास्ते पर जाएंगे। जैसा कि दिमित्री बुगाचेन्को ने लिखा है , यदि आप स्पार्क के लिए विकसित होते हैं, अर्थात, आपके पास स्काला का उपयोग करने के लिए हर कारण है, इसके अलावा, स्केला आपको बहुत अधिक कुशलता से और अधिक लचीले ढंग से अपने स्वयं के ट्रांसफॉर्मर और एस्टीमेटर को स्पार्कएमएल पाइपलाइन में एम्बेड करने की अनुमति देता है, लेकिन धीरे-धीरे कैसे काम करता है UDF में / पांडा कोड (JVM से निष्पादन योग्य पर कहा जाता है) पहले ही बहुत कुछ लिखा जा चुका है।

स्थापना संक्षिप्त

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

%spark.dep z.addRepo("bintray.com").url("http://dl.bintray.com/spark-packages/maven/") z.load("Azure:mmlspark:0.17") 

यह कहने योग्य है कि पुस्तकालय में उत्कृष्ट पिछड़ी संगतता है: इसके विपरीत, उदाहरण के लिए, XGBoost4j- स्पार्क, जिसे स्पार्क 2.3+ की न्यूनतम आवश्यकता होती है, यह चीज़ स्पार्क 2.2.1 में मिल गई, जो कि ज़ेपेलिन डॉकिन छवि और किसी भी कठिनाइयों के साथ आई थी। मैंने गौर नहीं किया।

नोट: MMLSpark लाइब्रेरी का अधिकांश भाग एक क्लस्टर पर ग्रिड की स्थापना के लिए समर्पित है, जिसके लिए CNTK मौजूद है (जो प्रलेखन को देखते हुए, तैयार किए गए cntk मॉडल को पढ़ना चाहिए) और एक बड़ा OpenCV ब्लॉक। हम अधिक सांसारिक कार्यों पर ध्यान केंद्रित करेंगे और मामले को "मॉडल" करने का प्रयास करेंगे, जब हमारे पास सारणीबद्ध डेटा के विशाल सरणियाँ हैं जो .csv, तालिकाओं या किसी अन्य प्रारूप में HDFS के रूप में हैं। इसलिए, हमें उन्हें पूर्व-संसाधित करने और एक मॉडल बनाने की आवश्यकता है, जबकि यह डेटा एक मशीन की मेमोरी में फिट नहीं होता है। इसलिए, हम क्लस्टर पर सभी कार्रवाई करेंगे।

पढ़ना और खुफिया विश्लेषण

सामान्य तौर पर, स्पार्क + ज़ेपेलिन बिल्कुल भी खराब नहीं है और ईडीए के कार्य के साथ सामना कर सकता है, लेकिन हम उनकी क्षमताओं का विस्तार करने का प्रयास करेंगे। सबसे पहले, हम उन वर्गों को आयात करते हैं जिनकी हमें आवश्यकता है:

• स्पार्क.sql.types से सभी को स्कीमा घोषित करने और डेटा को सही ढंग से पढ़ने के लिए
• सभी का उपयोग करने के लिए spark.sql.functions स्तंभों का उपयोग करें और अंतर्निहित कार्यों का उपयोग करें
• com.microsoft.ml.spark.SummarizeData , जिसे pandas का एक एनालॉग कहा जा सकता है। DataFrame.describe

 import com.microsoft.ml.spark.SummarizeData import org.apache.spark.sql.functions._ import org.apache.spark.sql.types._ 

हम अपनी फ़ाइल पढ़ते हैं:

 val titanicSchema = StructType( StructField("Passanger", ShortType) :: StructField("Survived", ShortType) :: StructField("PClass", ShortType) :: StructField("Name", StringType) :: StructField("Sex", StringType) :: StructField("Age", ShortType) :: StructField("SibSp", ShortType) :: StructField("Parch", ShortType) :: StructField("Ticket", StringType) :: StructField("Fare", FloatType) :: StructField("Cabin", StringType) :: StructField("Embarked", StringType) :: Nil ) val train = spark .read .schema(titanicSchema) .option("header", true) .csv("/mountV/titanic/train.csv") 

और अब डेटा को स्वयं, साथ ही उनके आकार को देखें:

 println(s"Train shape is: ${train.count} x ${train.columns.length}") train.limit(5).createOrReplaceTempView("trainHead") 

नोट: वास्तव में आपको createOrReplaceTempView का उपयोग करने की कोई आवश्यकता नहीं है जब आप सिर्फ .show (5) लिख सकते हैं। लेकिन शो में एक समस्या है: जब डेटा "चौड़ा" होता है, तो प्लेट का पाठात्मक प्रतिनिधित्व "तैरता है", और कुछ भी स्पष्ट नहीं होता है।

हमारे डेटा का आकार प्राप्त करें: Train shape is: 891 x 12
और अब sql सेल में हम पहली 5 पंक्तियों को देख सकते हैं:

 %sql select * from trainHead 

ठीक है, आइए सारांश देखें हमारी तालिका में:

 new SummarizeData() .setBasic(true) .setCounts(true) .setPercentiles(false) .setSample(true) .setErrorThreshold(0.25) .transform(train) .createOrReplaceTempView("summary") 

SummarizeData वर्ग के पास सरल Dataset.describe पर कई फायदे हैं, क्योंकि यह आपको लापता और अनूठे मूल्यों की संख्या की गणना करने की अनुमति देता है, और आपको मात्राओं की गणना करने की सटीकता को भी निर्दिष्ट करने की अनुमति देता है। यह वास्तव में बड़े डेटा के लिए महत्वपूर्ण हो सकता है।

डेटा की सफाई

टाइटैनिक में, सब कुछ हमेशा की तरह है - स्ट्रिंग स्तंभों का एक गुच्छा मान गायब है। और डेटा में कुछ प्रकार के कैंट (ऐसा लगता है कि डेटा का यह विशेष संस्करण बहुत विशिष्ट नहीं है) - लापता मानों से 25 लाइनें। सबसे पहले, इसे ठीक करें:

 val trainFiltered = train.filter(!(isnan(col("Survived")) || isnull(col("Survived")))) 

स्ट्रिंग डेटा प्रोसेसिंग

जहां तक ​​मुझे याद है, टाइटैनिक में Name और Cabin क्षेत्र से बाहर लाई गई विशेषताएँ सर्वश्रेष्ठ थीं। आप उन्हें बहुत आपूर्ति कर सकते हैं, लेकिन हम खुद को कुछ हद तक सीमित कर लेंगे, बस इतना ही नहीं लगभग एक ही कोड के उदाहरण देने के लिए।

आमतौर पर ऐसी चीजों के लिए नियमित अभिव्यक्ति का उपयोग करना सुविधाजनक होता है।
लेकिन हम इस मामले में चाहते हैं:

• सब कुछ वितरित किया गया था, डेटा उसी स्थान पर संसाधित किया गया था, जैसा कि यह था;
• सब कुछ SpakrML Transformer या Spark ML Estimator Classes के रूप में डिज़ाइन किया गया था, ताकि बाद में इसे पाइपलाइन में इकट्ठा किया जा सके।

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

स्पार्कलएम के पास ऐसे कार्यों के लिए "लगभग सार्वभौमिक" वर्ग है - SQLTranformer , लेकिन एसक्यूएल में लिखना स्पष्ट रूप से स्केल में लिखने से भी बदतर है, अगर केवल आइडिया में संकलन और वाक्यविन्यास हाइलाइटिंग के चरण में वाक्यविन्यास या विशिष्ट त्रुटियों को पकड़ने की क्षमता है। और यहाँ MMLSpark हमारी सहायता के लिए आता है, जहाँ एक सही मायने में सार्वभौमिक UDFTransformer लागू किया गया है :

 import com.microsoft.ml.spark.UDFTransformer 

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

 val miss = ".*miss\\..*".r val mr = ".*mr\\..*".r val mrs = ".*mrs\\..*".r val master = ".*master.*".r def convertNames(input: String): Option[String] = { Option(input).map(x => { x.toLowerCase match { case miss() => "Miss" case mr() => "Mr" case mrs() => "Mrs" case master() => "Master" case _ => "Unknown" } }) } 

(आप तुरंत देख सकते हैं कि गायब मानों के साथ काम करने के लिए स्काला कितना सुविधाजनक है, जो, वैसे, न केवल null , बल्कि Double.NaN भी हैं। Double.NaN , लेकिन वहाँ हैं ऐसा मजाक BooleanType चर, आदि में चूक के रूप में इस तरह की एक दुर्लभ चीज)

अब हमारे UserDefinedFunction घोषणा करें और इसके आधार पर तुरंत एक Transformer बनाएँ:

 val nameTransformUDF = udf(convertNames _) val nameTransformer = new UDFTransformer() .setUDF(nameTransformUDF) .setInputCol("Name") .setOutputCol("NameType") 

नोट: एक ज़ेपेलिन लैपटॉप में, यह सभी समान है, लेकिन जब यह सभी बाद में उत्पादन कोड में आता है, तो यह महत्वपूर्ण है कि सभी UDF उन कक्षाओं या ऑब्जेक्ट्स में हैं जो extends Serializable । स्पष्ट बात यह है कि आप कभी-कभी भूल सकते हैं और फिर लंबे समय के लिए खोद सकते हैं स्पार्क त्रुटियों के लंबे स्टैक के निशान को पढ़ने में क्या गलत है।

अब हमारे पास अभी भी Cabin क्षेत्र है। आइए इसे करीब से देखें:

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

 def getCabinsCount(input: String): Int = { Option(input) match { case Some(x) => x.split(" ").length case None => -1 } } val numPattern = "([az])([0-9]+)".r def getNumbersFromCabin(input: String): Int = { Option(input) match { case Some(x) => { x.split(" ")(0).toLowerCase match { case numPattern(sym, num) => Integer.parseInt(num) case _ => -1 } } case None => -2 } } val cabinsCountUDF = udf(getCabinsCount _) val numbersFromCabinUDF = udf(getNumbersFromCabin _) val cabinsCountTransformer = new UDFTransformer() .setInputCol("Cabin") .setOutputCol("CabinCount") .setUDF(cabinsCountUDF) val numbersFromCabinTransformer = new UDFTransformer() .setInputCol("Cabin") .setOutputCol("CabinNumber") .setUDF(numbersFromCabinUDF) 

अब आइए उम्र के लापता मूल्यों के साथ शुरू करते हैं। सबसे पहले, आइए ज़ेपलिन की विज़ुअलाइज़ेशन क्षमताओं का लाभ उठाएँ:

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

हमें आवश्यकता होगी:

 import org.apache.spark.sql.{Dataset, DataFrame} import org.apache.spark.ml.{Estimator, Model} import org.apache.spark.ml.param.{Param, ParamMap} import org.apache.spark.ml.util.Identifiable import org.apache.spark.ml.util.DefaultParamsWritable import com.microsoft.ml.spark.{HasInputCol, HasOutputCol} import com.microsoft.ml.spark.ConstructorWritable import com.microsoft.ml.spark.ConstructorReadable import com.microsoft.ml.spark.Wrappable 

आइए ConstructorWritable ध्यान दें, जो जीवन को सरल बनाता है। यदि हमारा Model एक "प्रशिक्षित" मॉडल है जो fit(), विधि देता है, जो पूरी तरह से इसके निर्माता द्वारा निर्धारित किया जाता है (और यह संभवतः 99% मामलों में है), तो हम अपने हाथों से क्रमबद्धता बिल्कुल नहीं लिख सकते हैं। यह वास्तव में बहुत सरल करता है और विकास को गति देता है, त्रुटियों को समाप्त करता है, और डेटासिस्टिस्ट और विश्लेषकों के लिए प्रवेश सीमा को भी कम करता है जो आमतौर पर पेशेवर प्रोग्रामर नहीं हैं।

हमारे Estimator वर्ग को परिभाषित करें। वास्तव में, यहां सबसे महत्वपूर्ण बात fit विधि है, बाकी तकनीकी बिंदु हैं:

 class GroupImputerEstimator(override val uid: String) extends Estimator[GroupImputerModel] with HasInputCol with HasOutputCol with Wrappable with DefaultParamsWritable { def this() = this(Identifiable.randomUID("GroupImputer")) val groupCol: Param[String] = new Param[String]( this, "groupCol", "Groupping column" ) def setGroupCol(v: String): this.type = super.set(groupCol, v) def getGroupCol: String = $(groupCol) override def fit(dataset: Dataset[_]): GroupImputerModel = { val meanDF = dataset .toDF .groupBy($(groupCol)) .agg(mean(col($(inputCol))).alias("groupMean")) .select(col($(groupCol)), col("groupMean")) new GroupImputerModel( uid, meanDF, getInputCol, getOutputCol, getGroupCol ) } override def transformSchema(schema: StructType): StructType = schema .add( StructField( $(outputCol), schema.filter(x => x.name == $(inputCol))(0).dataType ) ) override def copy(extra: ParamMap): Estimator[GroupImputerModel] = { val to = new GroupImputerEstimator(this.uid) copyValues(to, extra).asInstanceOf[GroupImputerEstimator] } } 

नोट: मैंने डिफॉल्टकॉपी का उपयोग नहीं किया, क्योंकि जब मैंने किसी कारण से कॉल किया, तो उसने कसम खाई कि मेरे पास कंस्ट्रक्टर नहीं है। \ <init> (java.lang.String), हालांकि ऐसा लगता है कि ऐसा नहीं होना चाहिए था। खैर, किसी भी मामले में, copy लागू करना आसान है।

अब आपको Model लागू करने की आवश्यकता है - एक वर्ग जो प्रशिक्षित मॉडल का वर्णन करता है और transform विधि को लागू करता है। हम इसे org.apache.spark.sql.functions में निर्मित org.apache.spark.sql.functions फ़ंक्शन के आधार पर बनाएंगे:

 class GroupImputerModel( val uid: String, val meanDF: DataFrame, val inputCol: String, val outputCol: String, val groupCol: String ) extends Model[GroupImputerModel] with ConstructorWritable[GroupImputerModel] { val ttag: TypeTag[GroupImputerModel] = typeTag[GroupImputerModel] def objectsToSave: List[Any] = List(uid, meanDF, inputCol, outputCol, groupCol) override def copy(extra: ParamMap): GroupImputerModel = new GroupImputerModel(uid, meanDF, inputCol, outputCol, groupCol) override def transform(dataset: Dataset[_]): DataFrame = { dataset .toDF .join(meanDF, Seq(groupCol), "left") .withColumn( outputCol, coalesce(col(inputCol), col("groupMean")) .cast(IntegerType)) .drop("groupMean") } override def transformSchema (schema: StructType): StructType = schema .add( StructField(outputCol, schema.filter(x => x.name == inputCol)(0).dataType) ) } 

अंतिम वस्तु जिसे हमें घोषित करने की आवश्यकता है, वह एक Reader , जिसे हम MMLSpark ConstructorReadable class का उपयोग करके लागू करते हैं:

 object GroupImputerModel extends ConstructorReadable[GroupImputerModel] 

पाइपलाइन निर्माण

पाइपलाइन में, मैं सामान्य SparkML वर्गों और MMLSpark - MultiColumnAdapter से अविश्वसनीय रूप से सुविधाजनक चीज़, दोनों को दिखाना चाहता हूं, जो आपको एक साथ कई स्तंभों में SparkML ट्रांसफार्मर लागू करने की अनुमति देता है (उदाहरण के लिए, उदाहरण के लिए, StringIndexer और OneHotEncoder इनपुट में बिल्कुल एक स्तंभ लेते हैं, जो उन्हें बदल देता है। दर्द में विज्ञापन):

 import org.apache.spark.ml.feature.{StringIndexer, VectorAssembler} import org.apache.spark.ml.Pipeline import com.microsoft.ml.spark.{MultiColumnAdapter, LightGBMClassifier} 

सबसे पहले, हम घोषित करेंगे कि हमारे पास कौन से कॉलम हैं:

 val catCols = Array("Sex", "Embarked", "NameType") val numCols = Array("PClass", "AgeNoMissings", "SibSp", "Parch", "CabinCount", "CabinNumber") 

अब एक स्ट्रिंग एनकोडर बनाएं:

 val stringEncoder = new MultiColumnAdapter() .setBaseStage(new StringIndexer().setHandleInvalid("keep")) .setInputCols(catCols) .setOutputCols(catCols.map(x => x + "_freqEncoded")) 

नोट: स्पार्कएमएल में स्किकिट-लर्न के विपरीत, स्ट्रिंग-इंडेक्सर आवृत्ति-एनकोडर के सिद्धांत पर काम करता है, और इसका उपयोग ऑर्डर रिलेशनशिप (यानी श्रेणी 0 <श्रेणी 1, और यह समझ में आता है) को निर्दिष्ट करने के लिए किया जा सकता है - यह दृष्टिकोण अक्सर अच्छा काम करता है निर्णायक पेड़।

हमारे Imputer करें:

 val missingImputer = new GroupImputerEstimator() .setInputCol("Age") .setOutputCol("AgeNoMissings") .setGroupCol("Sex") 

और VectorAssembler , चूंकि स्पार्कएमएल क्लासिफायर VectorType साथ काम करने में अधिक आरामदायक हैं:

 val assembler = new VectorAssembler() .setInputCols(stringEncoder.getOutputCols ++ numCols) .setOutputCol("features") 

अब हम MMLSpark - LightGBM के साथ आपूर्ति किए गए ग्रेडिएंट बूस्टिंग का उपयोग करेंगे, जो कि XGBoost और CatBoost के साथ इस एल्गोरिथम के सर्वश्रेष्ठ कार्यान्वयन के "बिग थ्री" में शामिल है। यह कई बार तेजी से, बेहतर और GBM कार्यान्वयन की तुलना में अधिक स्थिर काम करता है जो स्पार्कएमएल के पास है (यहां तक ​​कि जेवीएम पोर्ट अभी भी सक्रिय विकास में है):

 val catColIndices = Array(0, 1, 2) val lgbClf = new LightGBMClassifier() .setFeaturesCol("features") .setLabelCol("Survived") .setProbabilityCol("predictedProb") .setPredictionCol("predictedLabel") .setRawPredictionCol("rawPrediction") .setIsUnbalance(true) .setCategoricalSlotIndexes(catColIndices) .setObjective("binary") 

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

खैर, अंत में, हमारी पाइपलाइन घोषित करें:

 val pipeline = new Pipeline() .setStages( Array( missingImputer, nameTransformer, cabinsCountTransformer, numbersFromCabinTransformer, stringEncoder, assembler, lgbClf ) ) 

ट्रेनिंग

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

 val Array(trainDF, testDF) = trainFiltered.randomSplit(Array(0.8, 0.2)) println(s"Train rows: ${trainDF.count}\nTest rows: ${testDF.count}") // Train rows: 708 // Test rows: 158 val predictions = pipeline .fit(trainDF) .transform(testDF) 

मैट्रिक्स की सुविधाजनक गणना के लिए, हम MMLSpark से एक अन्य वर्ग का उपयोग करेंगे - ComputeModelStatistics :

 import com.microsoft.ml.spark.ComputeModelStatistics import com.microsoft.ml.spark.metrics.MetricConstants val modelEvaluator = new ComputeModelStatistics() .setLabelCol("Survived") .setScoresCol("predictedProb") .setScoredLabelsCol("predictedLabel") .setEvaluationMetric(MetricConstants.ClassificationMetrics) 

बुरा नहीं है, यह देखते हुए कि हमने डिफ़ॉल्ट सेटिंग्स नहीं बदली हैं।

हाइपरपरमेटर्स का चयन

MMLSpark में हाइपरपैरामीटर का चयन करने के लिए एक अलग शांत चीज है TuneHyperparameters , जो ग्रिड पर एक यादृच्छिक खोज को लागू करता है। हालांकि, दुर्भाग्य से, यह अभी तक Pipeline समर्थन नहीं करता है, इसलिए हम सामान्य स्पार्कएमएल CrossValidator उपयोग करेंगे:

 import org.apache.spark.ml.tuning.{ParamGridBuilder, CrossValidator} import org.apache.spark.ml.evaluation.BinaryClassificationEvaluator val paramSpace = new ParamGridBuilder() .addGrid(lgbClf.maxDepth, Array(3, 5)) .addGrid(lgbClf.learningRate, Array(0.05, 0.1)) .addGrid(lgbClf.numIterations, Array(100, 300)) .build println(s"Size of ParamsGrid: ${paramSpace.size}") // Size of ParamsGrid: 8 val crossValidator = new CrossValidator() .setEstimator(pipeline) .setEstimatorParamMaps(paramSpace) .setNumFolds(3) .setSeed(42L) .setEvaluator( new BinaryClassificationEvaluator() .setMetricName("areaUnderROC") .setLabelCol("Survived") .setRawPredictionCol("rawPrediction") ) val bestModel = crossValidator .fit(trainFiltered) 

दुर्भाग्य से, मुझे एक सुविधाजनक तरीका नहीं मिला कि आप उन मापदंडों के साथ परिणाम कैसे देख सकते हैं जिन पर उन्हें प्राप्त किया गया था। इसलिए, "राक्षसी" डिजाइनों का उपयोग करना आवश्यक है:

 crossValidator .getEstimatorParamMaps .zip(bestModel.avgMetrics) .foreach(x => { println( "\n" + x._1 .toSeq .foldLeft(new StringBuilder())( (a, b) => a .append(s"\n\t${b.param.name} : ${b.value}")) .toString + s"\n\tMetric: ${x._2}" ) }) 

जो हमें कुछ इस तरह देता है:

हमें सीखने की गति कम करने और पेड़ों की गहराई बढ़ाने के द्वारा सबसे अच्छा परिणाम मिला। इस आधार पर, खोज स्थान को समायोजित करना और उससे भी अधिक इष्टतम परिणाम आना संभव होगा, लेकिन हमारे पास ऐसा कोई लक्ष्य नहीं है।

निष्कर्ष

वास्तव में, जबकि MMLSpark में 0.17 संस्करण है और अभी भी अलग बग हैं। लेकिन मेरे द्वारा देखे गए सभी स्पार्क एक्सटेंशन में, MMLSpark के पास मेरी राय में सबसे व्यापक दस्तावेज और सबसे समझ में आने वाली स्थापना और कार्यान्वयन की प्रक्रिया है। Microsoft ने वास्तव में अभी तक इसका प्रचार नहीं किया है, केवल डेटाब्रिक पर एक रिपोर्ट थी , लेकिन इसमें डीप लर्निंग के बारे में अधिक था, और ऐसी नियमित चीजों के बारे में नहीं जो मैंने लिखा था।

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

इसलिए, मैं वास्तव में आशा करता हूं कि यह मिनी-ट्यूटोरियल (इसकी सभी स्पष्टता और सरलता के बावजूद) किसी के लिए उपयोगी होगा और बहुत समय और प्रयास को बचाने में मदद करेगा!