बिग डेटा के लिए स्ट्रीमिंग कोड पायथन


34

मेरे पास पायथन कोड है जिसे निम्नलिखित वर्कफ़्लो के माध्यम से पॉइंट शेपफाइल्स लेने के लिए डिज़ाइन किया गया है:

  1. अंक मिलाएं
  2. एकीकृत अंक, जैसे कि एक दूसरे के 1 मीटर के भीतर कोई भी बिंदु एक बिंदु बन जाता है
  3. फ़ीचर लेयर बनाएँ, जहाँ z <10 वाले पॉइंट चुने गए हैं
  4. बफर अंक
  5. बहुभुज 1 मीटर रिज़ॉल्यूशन को रेखापुंज करने के लिए
  6. पुनर्वर्गीकृत करें, जहां 1 - 9 = 1; NoData = 0

प्रत्येक शेपफाइल में लगभग 250,000 से 350,000 अंक होते हैं जो ~ 5x7 किमी को कवर करते हैं। इनपुट के रूप में उपयोग किए जाने वाले बिंदु डेटा पेड़ के स्थानों का प्रतिनिधित्व करते हैं। प्रत्येक बिंदु (यानी पेड़) का एक संबद्ध "z" मूल्य है जो मुकुट त्रिज्या का प्रतिनिधित्व करता है और बफर प्रक्रिया में उपयोग किया जाता है। मेरा इरादा एक अलग प्रक्रिया में अंतिम बाइनरी आउटपुट का उपयोग करने के लिए चंदवा कवर का वर्णन करने वाले एक रेखापुंज का उत्पादन करना है।

मैंने चार शेपफाइल्स के साथ एक परीक्षण चलाया और इसने 700MB का रास्टर तैयार किया और 35 मिनट (i5 प्रोसेसर और 8 जीबी रैम) लिया। यह देखकर कि मुझे इस प्रक्रिया को 3500 आकार-प्रकार पर चलाने की आवश्यकता होगी, मैं इस प्रक्रिया को कारगर बनाने के लिए किसी भी सलाह की सराहना करूंगा (संलग्न कोड देखें)। सामान्यतया, जियोप्रोसेसिंग बड़े डेटा से निपटने का सबसे अच्छा तरीका क्या है? अधिक विशेष रूप से, क्या कोड या वर्कफ़्लो में कोई जुड़वाँ हैं जो दक्षता बढ़ाने में मदद कर सकते हैं?

संपादित करें :

भूगर्भिक कार्यों के लिए समय (कुल का%):

  • मर्ज = 7.6%
  • एकीकृत = 7.1%
  • लिर = 0 की सुविधा
  • बफर = 8.8%
  • पॉली टू रैस्टर = 74.8%
  • Reclassify = 1.6%

यहाँ छवि विवरण दर्ज करें

# Import arcpy module
import arcpy

# Check out any necessary licenses
arcpy.CheckOutExtension("spatial")

# Script arguments
temp4 = arcpy.GetParameterAsText(0)
if temp4 == '#' or not temp4:
    temp4 = "C:\\gdrive\\temp\\temp4" # provide a default value if unspecified

Reclassification = arcpy.GetParameterAsText(1)
if Reclassification == '#' or not Reclassification:
    Reclassification = "1 9 1;NODATA 0" # provide a default value if unspecified

Multiple_Value = arcpy.GetParameterAsText(2)
if Multiple_Value == '#' or not Multiple_Value:
    Multiple_Value = "C:\\t1.shp;C:\\t2.shp;C:\\t3.shp;C:\\t4.shp" # provide a default value if unspecified

# Local variables:
temp_shp = Multiple_Value
Output_Features = temp_shp
temp2_Layer = Output_Features
temp_Buffer = temp2_Layer
temp3 = temp_Buffer

# Process: Merge
arcpy.Merge_management(Multiple_Value, temp_shp, "x \"x\" true true false 19 Double 0 0 ,First,#,C:\\#########omitted to save space

# Process: Integrate
arcpy.Integrate_management("C:\\gdrive\\temp\\temp.shp #", "1 Meters")

# Process: Make Feature Layer
arcpy.MakeFeatureLayer_management(temp_shp, temp2_Layer, "z <10", "", "x x VISIBLE NONE;y y VISIBLE NONE;z z VISIBLE NONE;Buffer Buffer VISIBLE NONE")

# Process: Buffer
arcpy.Buffer_analysis(temp2_Layer, temp_Buffer, "z", "FULL", "ROUND", "NONE", "")

# Process: Polygon to Raster
arcpy.PolygonToRaster_conversion(temp_Buffer, "BUFF_DIST", temp3, "CELL_CENTER", "NONE", "1")

# Process: Reclassify
arcpy.gp.Reclassify_sa(temp3, "Value", Reclassification, temp4, "DATA")

3
यह स्थापित करने के लिए कुछ प्रदर्शन समय कोड में डालने के लायक हो सकता है कि क्या समय का थोक एक या कुछ चरणों में जा रहा है - ताकि प्रदर्शन लाभ प्राप्त करने और खोजने के लिए उन पर ध्यान केंद्रित किया जा सके
PolyGeo

5
मुझे नहीं लगता कि आपके पास प्रदर्शन में सुधार करने के लिए कई विकल्प हैं यदि आप आर्कपी का उपयोग करते रहते हैं। शायद आप ऐसा करने के लिए अन्य उपकरणों को देख सकते हैं? FME या पोस्टगिस जैसे उपकरण?
tmske 10

3
यह स्पष्ट नहीं है कि किस प्रकार के पिक्सेल का उपयोग किया जा रहा है, लेकिन अगर यह "बाइट" है (जो इसे होना चाहिए), तो कच्चे डेटा का भंडारण 5000x7000 = 35Mb (~ 33.4MB) प्रति रेखापुंज होगा, जो वास्तव में उतना बड़ा नहीं है। हालांकि, 3500 का अगला आयाम (समय आयाम?) कुल कच्चे आकार को ~ 114GB तक बढ़ाता है।
माइक टी

5
हालाँकि, मैं इस विवरण से यह नहीं बता सकता कि एल्गोरिथ्म क्या कर रहा है (या करने का इरादा है), ज्यादातर मामलों में रेखांकन के बाद पॉइंट बफ़र्स को एक फोकल स्टैटिस्टिक (आमतौर पर एक माध्य या योग) के बाद अंक के विचलन द्वारा प्रतिस्थापित किया जाना चाहिए। परिणाम समान होगा लेकिन, लंबी बफरिंग और पॉली रैस्टराइजेशन चरणों से बचकर, इसे बहुत तेजी से प्राप्त किया जाएगा । मुझे (दृढ़ता से) संदेह है कि अतिरिक्त अतिरिक्त स्पीडअप प्राप्त किए जा सकते हैं, लेकिन प्रक्रिया के विवरण की अस्पष्टता के कारण विशिष्ट सलाह नहीं दे सकते।
whuber

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

जवाबों:


10

कुछ एल्गोरिथ्म में परिवर्तन होता है जो आपको मदद करना चाहिए।

विलय या एकीकरण से पहले अपने चयन को निष्पादित करें। यह बाद के कार्यों में काफी कटौती करेगा जो सबसे महंगे हैं।

मर्ज और एकीकृत दोनों मेमोरी महंगी हैं, इसलिए आप फीचर कक्षाओं में लाते समय सुविधाओं को खत्म करना चाहते हैं, और मर्ज के आकार को बनाए रखने और एकीकृत करने के लिए बाइनरी ट्री में अपने मर्ज करने की कोशिश करें। उदाहरण के लिए चार शेपफाइल्स के लिए आप दो शेपफाइल्स को मिलाते हैं और एकीकृत करते हैं; दो और आकार आकृति को मिलाएं और एकीकृत करें; दो परिणामी फीचर कक्षाओं को मर्ज करें और एकीकृत करें।

आपकी नौकरी की कतार आकार-प्रकार के संदर्भों की कतार के रूप में शुरू होती है। आपके पास परिणामों को रखने के लिए एक परिणाम कतार भी है। आपके समानांतर प्रोसेसिंग वर्कर के लिए रन () विधि ये ऑपरेशन करेगी: कतार से दो आइटम लें। यदि कोई वस्तु नहीं ली जाती है (कतार खाली है), कार्यकर्ता को समाप्त करें। यदि एक आइटम लिया जाता है, तो उस आइटम को सीधे परिणाम कतार में रखें।

यदि दो आइटम लिए गए हैं, प्रत्येक आइटम के लिए: यदि यह एक आकृति है, तो z <10 के लिए चयन करें और एक in_memor फीचर क्लास बनाएं; और, यह पहले से ही एक in_memory फीचर क्लास है और चयन चरण को पूरा करता है। एक नया in_memory सुविधा वर्ग बनाने के लिए दो in_memory सुविधा वर्ग मर्ज करें। मूल दो सुविधा कक्षाएं हटाएं। निष्पादित नई सुविधा वर्ग पर एकीकृत करता है। उस सुविधा वर्ग को परिणाम कतार में रखें।

फिर एक बाहरी लूप चलाते हैं। लूप आकार की कतार से शुरू होता है और 1. से अधिक की लंबाई के लिए परीक्षण करता है। यह फिर श्रमिकों के माध्यम से कतार चलाता है। यदि परिणाम कतार की लंबाई 1 से अधिक है, जबकि लूप श्रमिकों के माध्यम से चलने वाली एक अन्य समानांतर प्रसंस्करण को निष्पादित करता है, जब तक कि परिणाम कतार 1 in_memory फीचर क्लास नहीं है।

उदा। यदि आप 3500 से आकार के साथ शुरू करते हैं, तो आपकी पहली कतार में 3500 नौकरियां होंगी। दूसरे में 1750 नौकरियां होंगी। 875, 438, 219, 110, 55, 28, 14, 7, 4, 2, 1. आपकी बड़ी अड़चन स्मृति होगी। यदि आपके पास पर्याप्त मेमोरी नहीं है (और आप पहली परिणाम कतार के निर्माण में मेमोरी से बाहर चले जाएंगे, अगर ऐसा है), तो अपने एल्गोरिथ्म को संशोधित करके एक बार में 2 से अधिक फीचर क्लासेज मर्ज करें, जो कि कट जाएगा लंबे समय तक प्रसंस्करण समय के बदले में आपकी पहली परिणाम कतार का आकार। वैकल्पिक रूप से, आप आउटपुट फाइल लिख सकते हैं और in_memory फीचर क्लासेस का उपयोग कर सकते हैं। यह आपको काफी धीमा कर देगा, लेकिन मेमोरी टोंटी से अतीत हो जाएगा।

आपके द्वारा मर्ज किए जाने और एकीकृत होने के बाद ही सभी आकार-प्रकारों के साथ एक ही फ़ीचर वर्ग के साथ समाप्त होने के बाद, क्या आप बफ़र, पॉली को रेखापुंज, और पुनर्वर्गीकृत करते हैं। इस तरह वे तीन ऑपरेशन केवल एक बार किए जाते हैं और आप अपनी ज्यामिति को सरल रखते हैं।


+ In_memory कार्यस्थान का उपयोग करने के लिए यदि आपका डेटा मेमोरी में फिट होगा। यह महत्वपूर्ण रूप से जियोप्रोसेसिंग ऑपरेशन को गति देता है।
रयानडाल्टन

यह अच्छी चीज है। मुझे लगता है कि यह एक आरेख और कुछ psuedocode (या वास्तविक कोड!) के साथ भी बेहतर हो सकता है।
blah238

हाँ, काश मुझे कोड करने के लिए कुछ समय मिलता। मुझे वैसे भी एक नई समानांतर प्रसंस्करण डेमो स्क्रिप्ट लिखने की आवश्यकता है।
ब्लॉर्ड-कैस्टिलो

14

पहली बात मैं आपके सिस्टम के संसाधन उपयोग की निगरानी विंडोज 7 में रिसोर्स मॉनिटर या विस्टा / एक्सपी में परफ्यूम जैसी किसी चीज़ का उपयोग करके कर सकता हूँ कि क्या आप सीपीयू -, मेमोरी - या आईओ-बाउंड हैं

यदि आप मेमोरी या आईओ-बाउंड हैं, तो संभावना बहुत कम है कि आप हार्डवेयर को अपग्रेड कर सकते हैं, समस्या का आकार कम कर सकते हैं, या दृष्टिकोण को पूरी तरह से बदल सकते हैं।

यदि आप यह निर्धारित करते हैं कि आप सीपीयू-बाउंड हैं, तो मैं multiprocessingमॉड्यूल के साथ प्रयोग करूंगा , या कई अन्य पायथन-आधारित समानांतर प्रसंस्करण पैकेज उपलब्ध हैं, यह देखने के लिए कि क्या आप अपने कार्यों को तेज करने के लिए अधिक सीपीयू कोर का उपयोग कर सकते हैं।

बहुप्रचलितता और समानतावाद की चाल को एक अच्छी विभाजन योजना मिल रही है:

  1. आपको इनपुट्स को छोटे कामकाजी सेटों में विभाजित करने की अनुमति देता है, फिर परिणामों को इस तरह से पुन: संयोजित करता है जिससे समझ में आता है,
  2. ओवरहेड की कम से कम राशि जोड़ता है (कुछ सीरियल प्रसंस्करण की तुलना में अपरिहार्य है), और
  3. आपको इष्टतम प्रदर्शन के लिए सिस्टम के संसाधनों का सर्वोत्तम उपयोग करने के लिए कार्य सेट के आकार को समायोजित करने की अनुमति देता है।

आप इस उत्तर में बनाई गई स्क्रिप्ट का उपयोग एक प्रारंभिक बिंदु के रूप में कर सकते हैं: आर्किंग डेस्कटॉप के लिए आर्कपी / पाइथन के लिए बिल्डिंग शैडो बनाने के लिए पोर्टिंग एवेन्यू कोड?

इस ईएसआरआई जियोप्रोसेसिंग ब्लॉग पोस्ट को इस विषय पर भी देखें: पायथन मल्टीप्रोसेसिंग - दृष्टिकोण और विचार

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

मैं कुछ दिलचस्प पठन सामग्री के बारे में भी जानना चाहता हूँ यदि आप आर्कपी से परे देखना चाहते हैं:

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.