¿Optimizar y acelerar el código de ArcPy?

Question

De nuevo mis líneas de escorrentía superficial. Hice un script, resolviendo el tema cuando las líneas se cruzan con otras líneas. Algo así como la generalización. Como en la imagen de abajo. El problema es que tengo que resolver 30 millones. de estas líneas. Lo he probado con 20 000 líneas y el tiempo necesario para ejecutarlo fue de 2h 30 min. Así que, aproximadamente, si lo hago con 30 millones de líneas, el tiempo de ejecución es de 5 a 6 meses.

Soy un principiante en Python.

¿Cómo puedo ajustar mi script para que se ejecute más rápido?

Estoy usando Python 2.7.3, ArcGIS 10.2 y Windows 7. Pongo mi script aquí:

'

#IMPORT MODULES, SETTINGS    
# ##############################################################################
import arcpy, datetime
start = datetime.datetime.now()
arcpy.env.overwriteOutput = True
arcpy.env.workspace = r"C:\Users\david\Desktop\GAEC\TEST\TEST1.gdb"

# DEFINITION OF VARIABLES
# ##############################################################################
OL = "OL"                             # LAYER WITH LINES
OL_FC = "in_memory" + "\\" + "OL_FC"
OL_buff = "in_memory" + "\\" + "OL_buff"
memOne = "in_memory" + "\\" + "OL_one"
memSelect = "in_memory" + "\\" + "memSelect"
memErase = "in_memory" + "\\" + "OL_erase"
memOut = "in_memory" + "\\" + "OL_out"
memOutTemp = "in_memory" + "\\" + "OL_outTemp"
memDissolve = "in_memory" + "\\" + "memDissolve"
memSplit = "in_memory" + "\\" + "memSplit"
memUnsplit = "in_memory" + "\\" + "memUnsplit"
OL_final = "OL_final"

# TESTING AND CREATING FIELDS IN ATRB TABLE, CALCULATING LENGTH
# ##############################################################################
if len(arcpy.ListFields(OL, "LENGTH")) > 0:
    print "Table already has a field LENGTH!..."
else:
    arcpy.AddField_management(OL, "LENGTH", "LONG")
    print "Missinf field LENGTH -> creating..."
arcpy.CalculateField_management(OL, "LENGTH",  "!shape.length!", "PYTHON")
print "Calculate length for lines..."

if len(arcpy.ListFields(OL, "EDIT")) > 0:
    print "Table already has a field EDIT!..."
    arcpy.DeleteField_management(OL, "EDIT")
    arcpy.AddField_management(OL, "EDIT", "SHORT")
else:
    arcpy.AddField_management(OL, "EDIT", "SHORT")
    print "Missinf field EDIT -> creating..."

arcpy.MakeFeatureLayer_management(OL, OL_FC)
rows = arcpy.SearchCursor(OL_FC)
sql = '"LENGTH" < ' + str(10)
lengths = list()
lengths0 = list()
i = 1
a = -1

# CYCLE WHICH MAKE LIST OF LENGHTS, USED FOR NUMBER OF LINES (CYCLES)
# ##############################################################################
for row in rows:
    x = row.getValue("LENGTH")
    lengths.append(x)

# WHOLE PROGRAMM CYCLE
# ##############################################################################
for q in (lengths):
    # COUNTING LENGTHS FOR LINES, NEED TO BE UPDATED CAUSE LENGHTS ARE CHANGING
    rows0 = arcpy.SearchCursor(OL_FC)
    for row0 in rows0:
        x0 = row0.getValue("LENGTH")
        lengths0.append(x0)
        lengths0.sort()
    # ##########################################################################
    leng = lengths0[a]
    # SELECTION OF ACTUAL LONGEST LINE, STARTS FROM END OF THE LIST AND DESCENDING
    sql1 = '"LENGTH" = ' + str(leng)
    arcpy.SelectLayerByAttribute_management(OL_FC, "NEW_SELECTION", sql1)
    # ##########################################################################
    curA = arcpy.SearchCursor(OL_FC)
    for rowA in curA:
        # TESTING IF LINE WAS EDITED BEFORE (IF YES, FIELD 'EDIT' = 1, THEN SKIP)
        test0 = rowA.getValue("EDIT")
        if test0 != 1:
        # ######################################################################
            arcpy.MakeFeatureLayer_management(OL_FC, memOne)
            print "Line exported into independently layer"
            arcpy.Buffer_analysis(memOne, OL_buff, "1.3 Meters")
            print "Created buffer around the line"
            arcpy.SelectLayerByLocation_management(OL_FC, "INTERSECT", OL_buff, "", "NEW_SELECTION")
            curAA = arcpy.UpdateCursor(OL_FC)
            for w2 in curAA:
                # FILLING FIELD EDIT WITH 1, SETTING FIELD LENGTH TO 0
                # ##############################################################
                w2.setValue("EDIT", 1)
                w2.setValue("LENGTH", 0)
                curAA.updateRow(w2)
            arcpy.MakeFeatureLayer_management(OL_FC, memSelect)
            print "Exporting affected lines"
            test = int(arcpy.GetCount_management(OL_FC)[0])
            # TESTING IF LINE TOUCHES AT LEAST ONE ANOTHER LINE, IF NO, SKIP
            # ##################################################################
            if test != 1:
                arcpy.Dissolve_management(memSelect, memDissolve)
                arcpy.Erase_analysis(memDissolve, OL_buff, memErase)
                arcpy.SplitLine_management(memErase, memSplit)
                arcpy.UnsplitLine_management(memSplit, memUnsplit)
                arcpy.Merge_management([memUnsplit, memJedna], memOut)
                print "Merge with original line (which buffer erases)"
                arcpy.Snap_edit(memOut, [[memOne, "EDGE", "1.4 Meters"]])
                print "LINES ARE SNAPPED TO ORIGINAL LINES"
                # DELETING LINES THAT ARE SHORTER THAN 10 M
                # ##############################################################
                arcpy.MakeFeatureLayer_management(memOut, memOutTemp)
                arcpy.CalculateField_management(memOutTemp, "LENGTH",  "!shape.length!", "PYTHON")
                arcpy.SelectLayerByAttribute_management(memOutTemp, "NEW_SELECTION", sql)
                arcpy.DeleteFeatures_management(memOutTemp)
                print "Lines shorter than 10 m deleted"
                # FIRST CYCLE CREATES OL_finan, AFTER LINES ARE APPENDING TO FINAL
                # ##############################################################
                if i == 1:
                    arcpy.CopyFeatures_management(memOutTemp, OL_final)
                else:
                    arcpy.Append_management(memOutTemp, OL_final)
                    print "New layer is append to layer before"
            # LINES WITHOUT CROSSING ANY OTHER LINE
            # ##################################################################
            else:
                for w2 in curAA:
                    w2.setValue("EDIT", 1)
                    w2.setValue("LENGTH", 0)
                    arcpy.Append_management(OL_FC, OL_final)
                    curAA.updateRow(w2)
                print "Standalone line appends to final layer"
            print "Imputed i, i = " + str(i) + "..."
    # DELETE RAM MEMORY
    # ##############################################################
    arcpy.Delete_management("in_memory")
    # IMPUTED TO NEXT CYCLE
    # ##########################################################################
    i+=1
    a-=1

# DELETE ASSISTANT FILEDS
# ##############################################################
arcpy.DeleteField_management(memOutTemp, "LENGTH")
arcpy.DeleteField_management(memOutTemp, "EDIT")

# ENDING OF TIMER
# ##############################################################################
end = datetime.datetime.now()
print "\nStart: " + start.strftime("%Y-%m-%d %H:%M:%S")
print "End of script: " + end.strftime("%Y-%m-%d %H:%M:%S")

Answer 1

Además de utilizar el nuevo cursor arcpy.da, también sugeriría:

• Tienes muchos cursores de búsqueda diferentes en la misma capa, mira si puedes eliminar algunos de ellos y sacar tus atributos de uno o dos
• Aplicar un Añadir índice de atributos en cualquier columna que esté consultando
• Vea si puede eliminar la capa de selección por lógica de atributos y aplicar esa consulta en el argumento de la cláusula where en el cursor (esto eliminará muchos registros que no necesita iterar)

Answer 2

Además de las respuestas sobre el cambio de cursor y la reducción del número de ellos, también puedes paralelizar esto un poco usando subprocesos. Los subprocesos en Python sortean la limitación del Bloqueo Global del Intérprete (GIL) - a diferencia del multithreading en Python (una cosa diferente al multiprocesamiento). Aunque ArcGIS 10 utiliza el multiprocesamiento ahora, creo que todavía debe decirle explícitamente a ArcPy que lo haga y crear sus subprocesos en consecuencia. El número que usted crea es un acto de equilibrio sin embargo. Inicie demasiados y usted realmente ralentizará las cosas. Para las tareas de geoprocesamiento pesadas trabajo en una regla general de número de subprocesos = núcleos -1 (dejando un núcleo para ArcGIS y el sistema operativo y el resto puede ser acaparado por su proceso).

También puede crear una granja de geoprocesamiento y poner en servicio muchas máquinas. Hay una manera de hacer esto con una sola copia de ArcGIS, pero entra en la "zona gris" del acuerdo de licencia de software. ¡Lo he hecho en el pasado con el conocimiento y el interés de ESRI (quemando aproximadamente 50 núcleos a través de unas 20 máquinas), pero hay que tener cuidado acerca de dónde se encuentra legalmente!

Su alternativa sería recrear su proceso en el software FOSS4G y poner en servicio tantas máquinas de su red como pueda, repartiendo la tarea entre ellas. Dadas las escalas de tiempo de las que hablas, puede que tengas que considerar esta opción si los cambios sugeridos más unos cuantos subprocesos locales no te dan la velocidad que necesitas.

EDITAR Para la documentación sobre el multiprocesamiento en Python, véase aquí . Sólo hay que tener cuidado en caso de que haya algún cambio entre la v2.x y la 3.x.

Answer 3

Cambia a arcpy.da para todos tus cursores. Los antiguos objetos de cursor arcpy se rompieron en 10.1 sp2 y la única forma en que ESRI pudo arreglarlo fue creando los nuevos objetos de cursor arcpy.da.

Tenía un proceso que se ejecutaba en 10.1 sp1 que tardaba 18 horas utilizando los antiguos objetos cursor. Después de sp2 tardó más de 12 días antes de que lo matara. Los nuevos cursores arcpy.da tardan 4 horas.

Answer 4

Además de las sugerencias anteriores, también sugeriría utilizar comprensiones de listas para bucles simples. Por ejemplo:

rows = arcpy.SearchCursor(OL_FC)
for row in rows:
    x = row.getValue("LENGTH")
    lengths.append(x)

Cambia a:

lengths = [row.getValue("LENGTH") for row in arcpy.SearchCursor(OL_FC)]