पायस्पार्क और एमएलएलआईबी: यादृच्छिक वन भविष्यवाणियों की कक्षा की संभावनाएं

Question

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

मैं पीएसस्पर्क में RandomForestModel क्लासिफायर से कक्षा की संभावनाओं को कैसे निकाल सकता हूं?

यहाँ नमूना प्रलेखन कि केवल अंतिम वर्ग (नहीं संभाव्यता) प्रदान करता है में प्रदान की कोड है:

from pyspark.mllib.tree import RandomForest 
from pyspark.mllib.util import MLUtils 

# Load and parse the data file into an RDD of LabeledPoint. 
data = MLUtils.loadLibSVMFile(sc, 'data/mllib/sample_libsvm_data.txt') 
# Split the data into training and test sets (30% held out for testing) 
(trainingData, testData) = data.randomSplit([0.7, 0.3]) 

# Train a RandomForest model. 
# Empty categoricalFeaturesInfo indicates all features are continuous. 
# Note: Use larger numTrees in practice. 
# Setting featureSubsetStrategy="auto" lets the algorithm choose. 
model = RandomForest.trainClassifier(trainingData, numClasses=2, categoricalFeaturesInfo={}, 
            numTrees=3, featureSubsetStrategy="auto", 
            impurity='gini', maxDepth=4, maxBins=32) 

# Evaluate model on test instances and compute test error 
predictions = model.predict(testData.map(lambda x: x.features)) 

मैं किसी भी model.predict_proba() विधि नहीं दिख रहा है - मुझे क्या करना चाहिए ??

Answer 1

जहां तक ​​मैं यह कह सकता हूं कि वर्तमान संस्करण (1.2.1) में समर्थित नहीं है। मूल स्कैला कोड (tree.py) पर पाइथन रैपर केवल 'अनुमानित' फ़ंक्शंस को परिभाषित करता है, जो बदले में, संबंधित स्कैला समकक्षों (treeEnsembleModels.scala) को कॉल करता है। उत्तरार्द्ध द्विआधारी निर्णयों के बीच वोट लेकर निर्णय लेते हैं। एक बहुत साफ समाधान एक संभाव्य भविष्यवाणी प्रदान करना होता जो कि मनमाने ढंग से थ्रेसहोल्ड किया जा सकता है या स्केलर में आरओसी गणना के लिए उपयोग किया जा सकता है। भविष्य में रिलीज के लिए यह सुविधा जोड़ा जाना चाहिए!

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

पाइथन को स्पार्क (जावा में चलाने) में एकीकृत करने की कठिनाइयों के कारण नीचे दिया गया कोड मुश्किल है। एक बहुत सावधान रहना चाहिए कि कार्यकर्ता नोड्स को कोई जटिल डेटा न भेजें, जिसके परिणामस्वरूप धारावाहिक समस्याओं के कारण दुर्घटनाएं हो सकती हैं। स्पार्क संदर्भ का जिक्र करने वाला कोई भी कोड एक कार्यकर्ता नोड पर चलाया जा सकता है। साथ ही, किसी भी जावा कोड का जिक्र करने वाला कोई कोड क्रमबद्ध नहीं किया जा सकता है। उदाहरण के लिए, नीचे दिए गए कोड में ntrees के बजाय लेन (पेड़) का उपयोग करना मोहक हो सकता है - बैंग! जावा/स्कैला में ऐसे रैपर को लिखना बहुत अधिक सुरुचिपूर्ण हो सकता है, उदाहरण के लिए वर्कर नोड्स पर निर्णय पेड़ों पर लूप चलाकर और संचार लागत को कम करना।

नीचे दिया गया परीक्षण कार्य दर्शाता है कि predict_proba मूल उदाहरणों में उपयोग की गई भविष्यवाणी के समान परीक्षण त्रुटि देता है।

def predict_proba(rf_model, data): 
    ''' 
    This wrapper overcomes the "binary" nature of predictions in the native 
    RandomForestModel. 
    ''' 

    # Collect the individual decision tree models by calling the underlying 
    # Java model. These are returned as JavaArray defined by py4j. 
    trees = rf_model._java_model.trees() 
    ntrees = rf_model.numTrees() 
    scores = DecisionTreeModel(trees[0]).predict(data.map(lambda x: x.features)) 

    # For each decision tree, apply its prediction to the entire dataset and 
    # accumulate the results using 'zip'. 
    for i in range(1,ntrees): 
     dtm = DecisionTreeModel(trees[i]) 
     scores = scores.zip(dtm.predict(data.map(lambda x: x.features))) 
     scores = scores.map(lambda x: x[0] + x[1]) 

    # Divide the accumulated scores over the number of trees 
    return scores.map(lambda x: x/ntrees) 

def testError(lap): 
    testErr = lap.filter(lambda (v, p): v != p).count()/float(testData.count()) 
    print('Test Error = ' + str(testErr)) 


def testClassification(trainingData, testData): 

    model = RandomForest.trainClassifier(trainingData, numClasses=2, 
             categoricalFeaturesInfo={}, 
             numTrees=50, maxDepth=30) 

    # Compute test error by thresholding probabilistic predictions 
    threshold = 0.5 
    scores = predict_proba(model,testData) 
    pred = scores.map(lambda x: 0 if x < threshold else 1) 
    lab_pred = testData.map(lambda lp: lp.label).zip(pred) 
    testError(lab_pred) 

    # Compute test error by comparing binary predictions 
    predictions = model.predict(testData.map(lambda x: x.features)) 
    labelsAndPredictions = testData.map(lambda lp: lp.label).zip(predictions) 
    testError(labelsAndPredictions) 

सभी में, यह स्पार्क सीखने के लिए एक अच्छा अभ्यास था!

Answer 2

हालांकि, यह स्पार्क 1.5.0 और नई स्पार्क-एमएल एपीआई के साथ उपलब्ध होगा।

Answer 3

यह अब उपलब्ध है।

स्पार्क एमएल प्रदान करता है:

• एक predictionCol जिसमें लेबल की भविष्यवाणी की
• और एक probabilityCol कि प्रत्येक लेबल के लिए संभावनाओं के साथ एक वेक्टर होता है, यह क्या है आप की तलाश में हैं!
• तुम भी कच्चे मायने रखता है

अधिक जानकारी के लिए उपयोग कर सकते हैं, यहाँ स्पार्क प्रलेखन है: http://spark.apache.org/docs/latest/ml-classification-regression.html#output-columns-predictions

Answer 4

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

संभावना काफी आसान की गणना इस प्रकार किया जा सकता है: -

# say you have a testset against which you want to run your classifier 
    (trainingset, testset) =data.randomSplit([0.7, 0.3]) 
    # I converted the spark dataset containing the test data to pandas 
    ptd=testData.toPandas() 

    #Now get a count of number of labels matching the predictions 

    correct = ((ptd.label-1) == (predictions)).sum() 
    # here we had to change the labels from 0-9 as opposed to 1-10 since 
    #labels take the values from 0 .. numClasses-1 

    m=ptd.shape[0] 
    print((correct/m)*100)