ปรับปรุง Python Code สำหรับ Big Data


34

ฉันมีรหัส Python ที่ออกแบบมาเพื่อใช้ชี้ shapefiles ผ่านเวิร์กโฟลว์ต่อไปนี้:

  1. ผสานจุด
  2. รวมคะแนนเข้าด้วยกันเช่นจุดใด ๆ ที่อยู่ในระยะ 1 เมตรจากกันกลายเป็นจุดเดียว
  3. สร้างเลเยอร์คุณสมบัติโดยเลือกจุดที่มี z <10
  4. คะแนนบัฟเฟอร์
  5. รูปหลายเหลี่ยมถึงความละเอียด 1 เมตร
  6. จัดประเภทใหม่โดยที่ 1 - 9 = 1; NoData = 0

แต่ละรูปร่างไฟล์มีประมาณ 250,000 ถึง 350,000 จุดครอบคลุม ~ 5x7 กม. ข้อมูลจุดที่ใช้เป็นอินพุตเป็นตัวแทนของตำแหน่งต้นไม้ แต่ละจุด (เช่นต้นไม้) มีค่า "z" ที่เกี่ยวข้องซึ่งแสดงถึงรัศมีมงกุฎและใช้ในกระบวนการบัฟเฟอร์ ความตั้งใจของฉันคือการใช้เอาต์พุตไบนารีสุดท้ายในกระบวนการแยกต่างหากเพื่อสร้างแรสเตอร์ที่อธิบายถึงหลังคาครอบ

ฉันทดสอบกับรูปร่างสี่ไฟล์และสร้างแรสเตอร์ 700MB และใช้เวลา 35 นาที (โปรเซสเซอร์ i5 และ RAM 8GB) เห็นว่าฉันจะต้องเรียกใช้กระบวนการนี้ในรูปร่างที่ 3500 ฉันจะขอบคุณคำแนะนำใด ๆ เพื่อปรับปรุงกระบวนการ (ดูรหัสที่แนบมา) โดยทั่วไปแล้ววิธีที่ดีที่สุดในการจัดการกับการประมวลผลข้อมูลขนาดใหญ่คืออะไร โดยเฉพาะอย่างยิ่งมีการปรับแต่งโค้ดหรือเวิร์กโฟลว์ที่สามารถช่วยเพิ่มประสิทธิภาพได้หรือไม่?

แก้ไข :

เวลา (% ของทั้งหมด) สำหรับงานการประมวลผลทางภูมิศาสตร์

  • ผสาน = 7.6%
  • รวม = 7.1%
  • คุณสมบัติของ Lyr = 0
  • บัฟเฟอร์ = 8.8%
  • โพลีถึงแรสเตอร์ = 74.8%
  • จัดประเภทใหม่ = 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
ฉันไม่คิดว่าคุณมีตัวเลือกมากมายในการปรับปรุงประสิทธิภาพหากคุณใช้ ArcPy ต่อไป บางทีคุณสามารถดูเครื่องมืออื่น ๆ เพื่อทำสิ่งนี้? เครื่องมืออย่าง FME หรือ postgis?
tmske

3
ไม่ชัดเจนว่าใช้พิกเซลประเภทใด แต่ถ้าเป็น "Byte" (ซึ่งควรจะเป็น) การจัดเก็บข้อมูลดิบจะเป็น 5000x7000 = 35Mb (~ 33.4MB) ต่อแรสเตอร์ซึ่งจริงๆแล้วไม่ใหญ่มาก อย่างไรก็ตามมิติถัดไปของ 3500 (ขนาดเวลา?) เพิ่มขนาด raw ทั้งหมดเป็น ~ 114GB
Mike T

5
แม้ว่าฉันไม่สามารถบอกได้จากคำอธิบายนี้ว่าอัลกอริทึมกำลังทำอะไร (หรือตั้งใจจะทำ) ในกรณีส่วนใหญ่จุดบัฟเฟอร์ตามด้วย rasterization ควรถูกแทนที่ด้วย rasterization ของจุดตามด้วยสถิติโฟกัส ผลที่ได้จะเหมือนกัน แต่โดยหลีกเลี่ยงบัฟเฟอร์ยาวและแรสเตอร์โพลีขั้นตอนก็จะรับได้มากได้เร็วขึ้น ฉัน (อย่างยิ่ง) สงสัยว่าจะได้รับการเร่งความเร็วเพิ่มมาก แต่ไม่สามารถให้คำแนะนำเฉพาะเนื่องจากความคลุมเครือของคำอธิบายของกระบวนการ
whuber

2
บัฟเฟอร์รอบจุดคือขนาดตัวแปร (ขึ้นอยู่กับค่า z ของจุด) ฉันคิดว่ายังคงทำสถิติโฟกัสคุณจะต้องแยกคะแนนผลตามค่า z และทำสถิติแรสเตอร์และโฟกัสในแต่ละชุด (ใช้ z เป็นรัศมีในย่านวงกลมที่มีค่าสูงสุดเป็นสถิติ) จากนั้นเรียกใช้สถิติเซลล์ในแรสเตอร์ทั้ง 9 รายการด้วยค่าสถิติสูงสุดเพื่อรวมผลลัพธ์เข้าด้วยกัน (ซึ่งยังคงอาจจะมากเร็วกว่าบัฟเฟอร์และ Rasterize กับชุดข้อมูลขนาดใหญ่.)
blord-Castillo

คำตอบ:


10

การเปลี่ยนแปลงอัลกอริทึมบางอย่างที่ควรช่วยคุณ

ดำเนินการการเลือกของคุณก่อนรวมหรือผสาน สิ่งนี้จะลดลงอย่างมากในฟังก์ชั่นภายหลังซึ่งแพงที่สุด

การผสานและผสานรวมนั้นมีทั้งความทรงจำที่มีราคาแพงดังนั้นคุณจึงต้องการที่จะกำจัดฟีเจอร์ต่าง ๆ ตามที่คุณนำมาใช้ในคลาสของฟีเจอร์และพยายามทำการผสานของคุณในต้นไม้ไบนารีเพื่อให้ขนาดของการผสานและรวมเข้าด้วยกัน เช่นสำหรับสี่ Shapefiles คุณรวมสอง Shapefiles และรวมเข้าด้วยกัน รวมสองไฟล์รูปร่างและรวมเข้าด้วยกัน; รวมคลาสคุณลักษณะทั้งสองที่ได้และรวมเข้าด้วยกัน

คิวงานของคุณเริ่มต้นเป็นคิวของการอ้างอิง shapefile คุณมีคิวผลลัพธ์เพื่อวางผลลัพธ์ เมธอด run () สำหรับผู้ปฏิบัติงานประมวลผลแบบขนานของคุณจะทำการดำเนินการเหล่านี้: นำรายการสองรายการออกจากคิว หากไม่มีรายการใด (คิวว่างเปล่า) ให้ยกเลิกผู้ปฏิบัติงาน หากมีไอเท็มหนึ่งรายการให้วางไอเท็มนั้นลงในคิวผลลัพธ์

หากมีการใช้งานสองไอเท็มสำหรับแต่ละไอเท็ม: ถ้าเป็น shapefile ให้เลือกสำหรับ z <10 และสร้างคลาสคุณลักษณะ in_memory; มิฉะนั้นมันเป็นคลาสคุณลักษณะ in_memory แล้วและข้ามขั้นตอนการเลือก รวมคลาสฟีเจอร์ in_memory สองคลาสเพื่อสร้างคลาสฟีเจอร์ in_memory ใหม่ ลบคลาสฟีเจอร์ดั้งเดิมสองคลาส ดำเนินการผสานรวมกับคลาสคุณลักษณะใหม่ วางคลาสคุณลักษณะนั้นลงในคิวผลลัพธ์

จากนั้นรันวงนอกขณะที่ ลูปเริ่มต้นด้วยคิว shapefile และทดสอบความยาวที่มากกว่า 1 จากนั้นรันคิวผ่านพนักงาน หากคิวผลลัพธ์มีความยาวมากกว่า 1 ลูป while จะเรียกใช้การประมวลผลแบบขนานอื่นที่รันผ่านพนักงานจนกว่าคิวผลลัพธ์จะเป็น 1 คุณลักษณะคลาส in_memory

เช่นถ้าคุณเริ่มต้นด้วย 3500 รูปร่างไฟล์คิวแรกของคุณจะมี 3,500 งาน ประการที่สองจะมี 1,750 งาน 875, 438, 219, 110, 55, 28, 14, 7, 4, 2, 1 คอขวดขนาดใหญ่ของคุณจะเป็นหน่วยความจำ หากคุณมีหน่วยความจำไม่เพียงพอ (และคุณจะมีหน่วยความจำไม่เพียงพอในการสร้างคิวผลลัพธ์แรกถ้าเป็นกรณีนี้) จากนั้นปรับเปลี่ยนอัลกอริทึมของคุณเพื่อรวมคลาสฟีเจอร์มากกว่า 2 คลาสในครั้งเดียวแล้วผสานเข้าด้วยกัน ขนาดของคิวผลลัพธ์แรกของคุณเพื่อแลกกับเวลาในการประมวลผลที่นานขึ้น คุณสามารถเขียนไฟล์เอาต์พุตและข้ามโดยใช้คลาสคุณลักษณะ in_memory สิ่งนี้จะทำให้คุณช้าลงอย่างมาก แต่จะผ่านคอขวดของหน่วยความจำ

หลังจากที่คุณทำการผสานและรวมเข้ากับ Shapefiles ทั้งหมดแล้วจบด้วยคลาสฟีเจอร์เดียวคุณทำบัฟเฟอร์, โพลีไปยังแรสเตอร์และจัดประเภทใหม่ ด้วยวิธีนี้การดำเนินการทั้งสามนั้นทำได้เพียงครั้งเดียวและทำให้เรขาคณิตของคุณง่ายขึ้น


+1 สำหรับการใช้พื้นที่ทำงาน in_memoryหากข้อมูลของคุณจะพอดีกับหน่วยความจำ มันเพิ่มความเร็วในการดำเนินการทางภูมิศาสตร์
RyanDalton

นี่คือสิ่งที่ดี ฉันคิดว่ามันน่าจะดีกว่าด้วยไดอะแกรมและ psuedocode (หรือโค้ดจริง!)
blah238

ใช่ฉันหวังว่าฉันมีเวลาที่จะผูกพันกับรหัส ฉันต้องเขียนสคริปต์สาธิตการประมวลผลแบบขนานใหม่อยู่ดี
blord-castillo

14

สิ่งแรกที่ผมจะทำคือการตรวจสอบระบบของการใช้ทรัพยากรที่ใช้สิ่งที่ต้องการตรวจสอบทรัพยากรใน Windows 7 หรือperfmonใน Vista / XP ที่จะได้รับความรู้สึกสำหรับว่าคุณจะเป็นCPU - หน่วยความจำ - หรือIO-ผูกพัน

หากคุณเป็นหน่วยความจำหรือข้อ จำกัด IO มีโอกาสน้อยมากที่คุณสามารถทำได้ยกเว้นการอัพเกรดฮาร์ดแวร์ลดขนาดของปัญหาหรือเปลี่ยนวิธีการทั้งหมด

หากคุณพิจารณาว่าคุณเป็น CPU-bound ฉันจะทดลองกับmultiprocessingโมดูลหรือหนึ่งในแพ็คเกจการประมวลผลแบบขนาน Python อื่น ๆ ที่มีอยู่เพื่อดูว่าคุณสามารถใช้ CPU core เพิ่มเติมเพื่อเร่งความเร็วการทำงานของคุณหรือไม่

เคล็ดลับในการประมวลผลหลายตัวและความขนานโดยทั่วไปคือการหารูปแบบการแบ่งที่ดีที่:

  1. ช่วยให้คุณสามารถแยกอินพุตเป็นชุดการทำงานที่เล็กลงจากนั้นรวมผลลัพธ์อีกครั้งในลักษณะที่เหมาะสม
  2. เพิ่มค่าใช้จ่ายจำนวนน้อยที่สุด (บางอันไม่สามารถหลีกเลี่ยงได้เมื่อเทียบกับการประมวลผลแบบอนุกรม) และ
  3. ช่วยให้คุณปรับขนาดของชุดการทำงานเพื่อใช้ทรัพยากรของระบบเพื่อประสิทธิภาพที่ดีที่สุด

คุณสามารถใช้สคริปต์ที่ฉันสร้างขึ้นในคำตอบนี้เป็นจุดเริ่มต้น: รหัส Porting Avenue สำหรับการสร้าง Building Shadows ไปที่ ArcPy / Python สำหรับ ArcGIS Desktop หรือไม่

ดูโพสต์บล็อกการประมวลผลทางภูมิศาสตร์ ESRI นี้ในหัวข้อ: การประมวลผลแบบ หลามของ Python - แนวทางและข้อควรพิจารณา

ฉันคิดว่ากรณีของคุณจะมีความท้าทายมากขึ้นเนื่องจากลักษณะของ "กล่องดำ" มากกว่าของเครื่องมือที่คุณใช้แทนที่จะเป็นรูปทรงเรขาคณิตที่ละเอียดยิ่งขึ้นที่ฉันทำงานด้วย บางทีการทำงานกับอาร์เรย์NumPyอาจมีประโยชน์

ฉันยังเจอเนื้อหาการอ่านที่น่าสนใจอีกด้วยถ้าคุณต้องการที่จะมองไปไกลกว่า arcpy:

  • การประมวลผลแบบขนานอัลกอริทึมสำหรับระบบสารสนเทศภูมิศาสตร์ สำนักพิมพ์ CRC, 1997. Richard Healey, Steve Dowers, Bruce Gittings, Mike J Mineter
  • เร่งการประมวลผลเชิงภาพกับละเอียดและหยาบข้าวขนานในหญ้า เอกสารประกอบการประชุมผู้ใช้ FOSS / GRASS ประจำปี 2547 - กรุงเทพฯ, ประเทศไทย, ระหว่างวันที่ 12-14 กันยายน 2547 Onil Nazra Persada, Thierry Goubier
  • เร่งการประมวลผลชุดของการวิเคราะห์เชิงพื้นที่แรสเตอร์โดยใช้ GPU คอมพิวเตอร์และธรณีศาสตร์, เล่มที่ 45, สิงหาคม 2012, หน้า 212–220 Mathias Steinbach, Reinhard Hemmerling
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.