python - क्या स्पार्क केमिया बिगडाटा को संभालने में असमर्थ हैं?




apache-spark k-means (2)

केमीन्स के training लिए कई पैरामीटर हैं, आरंभिक विधा के साथ किमी के लिए डिफ़ॉल्ट || समस्या यह है कि यह पहले 13 चरणों में जल्दी (10min से कम) मार्च करता है, लेकिन फिर पूरी तरह से लटका देता है , बिना त्रुटि के!

न्यूनतम उदाहरण जो समस्या को पुन: पेश करता है (यदि मैं 1000 अंक या यादृच्छिक आरंभ का उपयोग करता हूं तो यह सफल होगा):

from pyspark.context import SparkContext

from pyspark.mllib.clustering import KMeans
from pyspark.mllib.random import RandomRDDs


if __name__ == "__main__":
    sc = SparkContext(appName='kmeansMinimalExample')

    # same with 10000 points
    data = RandomRDDs.uniformVectorRDD(sc, 10000000, 64)
    C = KMeans.train(data, 8192,  maxIterations=10)    

    sc.stop()

काम कुछ नहीं करता है (यह सफल नहीं होता है, असफल या प्रगति नहीं करता है ..), जैसा कि नीचे दिखाया गया है। Executors टैब में कोई सक्रिय / विफल कार्य नहीं हैं। Stdout और Stderr लॉग में कुछ भी विशेष रूप से दिलचस्प नहीं है:

अगर मैं 8192 के बजाय k=81 उपयोग करता हूं, तो यह सफल होगा:

ध्यान दें कि takeSample() की दो कॉल एक समस्या नहीं होनी चाहिए , क्योंकि यादृच्छिक आरंभीकरण मामले में दो बार कॉल किया गया था।

तो, क्या हो रहा है? क्या स्पार्क के किले पैमाने पर असमर्थ हैं ? क्या कोई जानता है? क्या आप पुन: पेश कर सकते हैं?

यदि यह एक स्मृति मुद्दा था, तो मुझे चेतावनी और त्रुटियां मिलेंगी, जैसा कि मैं पहले भी था

नोट: प्लेसबॉर्डो की टिप्पणियां क्लाइंट मोड में नौकरी के निष्पादन पर आधारित हैं, जहां ड्राइवर के कॉन्फ़िगरेशन अमान्य हैं, जिससे निकास कोड 143 और ऐसा होता है (इतिहास संपादित करें देखें), क्लस्टर मोड में नहीं, जहां कोई त्रुटि नहीं है । आवेदन बस लटका हुआ है

जीरो 323 से: स्पार्क मोलिब केमन्स एल्गोरिथ्म बहुत धीमा क्यों है? संबंधित है, लेकिन मुझे लगता है कि वह कुछ प्रगति देखती है, जबकि मेरी फांसी, मैंने एक टिप्पणी छोड़ दी ...


मुझे लगता है कि 'फांसी' इसलिए है क्योंकि आपके निष्पादक मरते रहते हैं। जैसा कि मैंने एक साइड वार्तालाप में उल्लेख किया है, यह कोड मेरे लिए, स्थानीय रूप से और एक क्लस्टर में, पिप्सपार्क और स्काला में ठीक चलता है। हालाँकि, इसे जितना चाहिए उससे अधिक समय लगता है। यह लगभग हर समय k- साधनों में बिताया जाता है || प्रारंभ।

मैंने दो मुख्य सुधारों को ट्रैक करने के लिए https://issues.apache.org/jira/browse/SPARK-17389 खोला, जिनमें से एक का आप अभी उपयोग कर सकते हैं। संपादित करें: वास्तव में, https://issues.apache.org/jira/browse/SPARK-11560 भी https://issues.apache.org/jira/browse/SPARK-11560

सबसे पहले, कुछ कोड ऑप्टिमाइज़ेशन हैं जो लगभग 13% तक की तेजी को रोक देंगे।

हालाँकि, अधिकांश समस्या यह है कि यह k- साधनों के 5 चरणों के लिए डिफ़ॉल्ट है || init, जब ऐसा लगता है कि 2 लगभग हमेशा की तरह अच्छा है। आप स्पीडअप देखने के लिए इनिशियलाइज़ेशन स्टेप्स को 2 पर सेट कर सकते हैं, खासकर उस स्टेज में जो अभी लटका हुआ है।

मेरे लैपटॉप पर मेरे (छोटे) टेस्ट में, इनिट टाइम दोनों बदलावों के साथ 5:54 से 1:41 तक चला गया, ज्यादातर इनिट स्टेप्स सेट करने के कारण।


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

countByKey, countByValue, इकट्ठा करें

अगर आपको वास्तव में RDD के इन मूल्यों में से हर एक की आवश्यकता है और डेटा मेमोरी में फिट होने के लिए बहुत बड़ा है, तो आप RDD को फ़ाइलों को लिख सकते हैं या RDD को एक डेटाबेस में निर्यात कर सकते हैं जो सभी डेटा को रखने के लिए पर्याप्त है। जैसा कि आप एक एपीआई का उपयोग कर रहे हैं, मुझे लगता है कि आप ऐसा करने में सक्षम नहीं हैं (सभी कोड को फिर से लिख सकते हैं? मेमोरी बढ़ाएं)। मुझे लगता है कि RunAl एल्गोरिदम विधि में यह संग्रहणीय वस्तु वास्तव में (जीडीपीटीएस ( https://databricks.gitbooks.io/databricks-spark-knowledge-base/content/best_practices/dont_call_collect_on_a_very_large_rdd.html ) ...





bigdata