एमएलआईबीबी टू ब्रीज़ वेक्टर/मैट्रिस org.apache.spark.mllib स्कोप के लिए निजी हैं?

Question

मैंने कहीं पढ़ा है कि एमएलआईबीबी स्थानीय वैक्टर/मैट्रिस वर्तमान में ब्रीज़ कार्यान्वयन को लपेट रहे हैं, लेकिन एमएलआईबीबी को ब्रीज़ वेक्टर/मैट्रिस में परिवर्तित करने के तरीके org.apache.spark.mllib स्कोप के लिए निजी हैं। इसके आसपास काम करने का सुझाव org.apache.spark.mllib.something पैकेज में अपना कोड लिखना है।

क्या ऐसा करने का कोई बेहतर तरीका है? क्या आप कुछ प्रासंगिक उदाहरण उद्धृत कर सकते हैं?

धन्यवाद और सादर,

Answer 1

मैं यह समझ के रूप में, स्पार्क लोगों (ब्रीज सहित) तृतीय पक्ष एपीआई का पर्दाफाश नहीं करना चाहती है ताकि यह अगर वे उनसे दूर जाने का फैसला बदलने के लिए आसान है।

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

Answer 2

मैंने वही समाधान किया जैसा @dlwh ने सुझाया था।

package org.apache.spark.mllib.linalg 

object VectorPub { 

    implicit class VectorPublications(val vector : Vector) extends AnyVal { 
    def toBreeze : breeze.linalg.Vector[scala.Double] = vector.toBreeze 

    } 

    implicit class BreezeVectorPublications(val breezeVector : breeze.linalg.Vector[Double]) extends AnyVal { 
    def fromBreeze : Vector = Vectors.fromBreeze(breezeVector) 
    } 
} 

सूचना है कि निहित वर्ग AnyVal फैली जब उन तरीकों

Answer 3

यहाँ बुला एक नई वस्तु के आवंटन को रोकने के लिए सबसे अच्छा मैं अब तक राशि है: यहाँ कोड है कि यह करता है। @dlwh पर ध्यान दें: कृपया इसमें कोई भी सुधार प्रदान करें जो आपको हो सकता है।

समाधान मैं के साथ आ सकता है - कि mllib .linalg पैकेज अंदर कोड नहीं डाल करता है - एक नई हवा DenseVector करने के लिए प्रत्येक वेक्टर कन्वर्ट करने के लिए है।

val v1 = Vectors.dense(1.0, 2.0, 3.0) 
val v2 = Vectors.dense(4.0, 5.0, 6.0) 
val bv1 = new DenseVector(v1.toArray) 
val bv2 = new DenseVector(v2.toArray) 
val vectout = Vectors.dense((bv1 + bv2).toArray) 
vectout: org.apache.spark.mllib.linalg.Vector = [5.0,7.0,9.0] 

Answer 4

यह समाधान स्पार्क के पैकेज में कोड डालने से बचा जाता है और घने वैक्टर करने के लिए विरल परिवर्तित करने से बचा जाता है:

def toBreeze(vector: Vector) : breeze.linalg.Vector[scala.Double] = vector match { 
     case sv: SparseVector => new breeze.linalg.SparseVector[Double](sv.indices, sv.values, sv.size) 
     case dv: DenseVector => new breeze.linalg.DenseVector[Double](dv.values) 
    }