Mais

A execução do código Python leva muito tempo (mais de 2 horas)? (Arcgis10.1)

A execução do código Python leva muito tempo (mais de 2 horas)? (Arcgis10.1)


Estou executando este código Python, no qual estou tentando determinar a posição da parcela vizinha (norte, sul, leste, oeste).

Funciona bem, mas demorou 2 horas para apenas 50 pacotes!

Acho que algo está errado. Este tempo de execução é normal? Você tem alguma sugestão para torná-lo mais rápido?

Estou usando arcgis10.1, arcpy, Python2.7 import arcpy import math import arcview

arcpy.env.workspace = "D: /Users/saadiya/Documents/ArcGIS/Default1.gdb" arcpy.env.overwriteOutput = True workspace = "C: / Saadia / SAFTOP / Parcelle et rivrains / simulação arcgis" para i no intervalo (1,50): expression = '"src_OBJECTID" =' + str (i) output_table = "table" + str (i) arcpy.PolygonNeighs_analysis ("P_dataset", "Voisins") arcpy.TableSelect_analysis ("Voisins", output_table , expression) arcpy.MakeFeatureLayer_management ("P_dataset", "Parcelles_class1_copy") arcpy.AddJoin_management ("Parcelles_class1_copy", "OBJECTID", output_table, "nbr_OBJECTID", "KEEP_ALL_2" target_parcel_2 "target_parcel_2 "P_dataset.OBJECTID" = '+ str (i) #print whereclause1 arcpy.Select_analysis ("Parcelles_class1_copy", target_parcel, whereclause1) Neighbours = "Neighbours_2" + str (i) whereclause2 = output_table_2 +'. Src_OBJECTID = '+ str (i) #print whereclause2 arcpy.Select_analysis ("Parcelles_class1_copy", Neighbours, whereclause2) arcpy.RemoveJoin_management ("Parcelles_class1_copy", output_table) target_ne ighbor_parcels = "target_neighbor_parcels_2" + str (i) arcpy.Union_analysis ([target_parcel, Neighbours], target_neighbor_parcels, "ALL") centroide = "centroide_2" + str (i) arcpy.FeatureToPoint_management (target_neighbor_parcels, centroide) arcpy cur = arcpy.UpdateCursor (centroide) arcpy.AddField_management (centroide, "Gisement", "DOUBLE") arcpy.AddField_management (centroide, "Orientation", "TEXT") arcpy.Delete_management (output_table) arcpy.Delete_management (target_parcel) arcpy. Delete_management (Neighbours) arcpy.Delete_management (target_neighbor_parcels) cur = arcpy.UpdateCursor (centroide) para linha em cur: a = output_table_2 + "_ src_FID_1" #print a condition = row.getValue (a) if (condição == 0): PointX = row.getValue ("POINT_X") PointY = row.getValue ("POINT_Y") end_x = PointX end_y = PointY elif (condição! = 0): PointX = row.getValue ("POINT_X") PointY = row.getValue ("POINT_Y ") #print end_x #print end_y #print PointX #print PointY dx = (end_x - PointX) dy = (end_y - PointY) #print dx #print dy azimuth = math.atan2 (dx, dy) #print azimuth azimuth_gr = azimuth * 200 / 3.14519 print azimuth_gr if (dy> = 0 e dx> = 0): print 1 azimuth_correct = azimuth_gr elif (dy> = 0 e dx <= 0): print 2 azimuth_correct = 200- azimuth_gr elif (dy <= 0 e dx <= 0): print 3 azimuth_correct = 200 + azimuth_gr elif (dy <= 0 e dx> = 0 ): print 4 azimuth_correct = 400 - azimuth_gr print azimuth_correct row.setValue ("Gisement", azimuth_correct) cur.updateRow (row) Position = row.getValue ("Gisement") #print Position if (Position> 45 and Position <= 135 ): Orient = "Est" elif (Posição> 135 e Posição <= 225): Orient = "Sud" elif (Posição> 225 e Posição <= 315): Orient = "Ouest" elif (Posição> 315 e Posição <= 400): Orient = "Nord" elif (Posição> 0 e Posição <= 45): Orient = "Nord" elif (Posição == 0): Orient = "" print Orient row.setValue ("Orientation", Orient) cur .updateRow (linha)

Eu tive a mesma experiência, mas percebi que quando converti o script para uma ferramenta de script ArcGIS, o tempo de execução caiu para 12 minutos. Uma ferramenta de script é como uma caixa de ferramentas. Você conecta seu script à ferramenta. Você precisará adicionar algumas linhas em seu script para definir os parâmetros. Isso é feito por meio da função GetParameterAsText ArcPy. Este http://help.arcgis.com/en/arcgisdesktop/10.0/help/index.html#//001500000006000000.htm fornece um tour rápido sobre como criar ferramentas de script.


Eu confirmaria como @Vince sugere se seus conjuntos de dados de entrada têm índices espaciais. Se suas entradas são Shapefiles, então, por padrão, eles não têm índices espaciais e precisam ser construídos.

Outra sugestão que irá acelerar o seu código é substituir o cursor que você está usando por um cursor dodamódulo conforme descrito aqui.


Eu não entendo totalmente o resultado da sua análise, mas parece que para cada recurso sendo avaliado você está mexendo muito - copiando conjuntos de dados, juntando-os, adicionando campos, excluindo-os. Se você não precisa fazê-los todas as vezes, faça-os uma vez fora do seu ciclo.

Alguns benchmarking podem ajudá-lo a descobrir onde está o gargalo. Você pode fazer algo assim, adicionando estas linhas na parte superior do seu arquivo:

import time start_time = time.time ()

e onde você quiser ver o tempo decorrido, adicione:

print time.time () - start_time

Pare / elimine um processo a partir da linha de comando após um determinado período de tempo

Eu tenho um código Python que escuta e detecta sons ambientais. Não é projeto meu, encontrei na web (SoPaRe). Com o comando ./sopare.py -l, ele começa a gravar sons, mas em loop infinito. Quando eu quiser pará-lo, preciso pressionar Ctrl + C.

Meu objetivo é parar este programa automaticamente após 10 segundos, mas quando conversei com o autor ele disse que o programa não tem limitador de tempo.

Tentei matá-lo via kill PID, mas o PID muda toda vez que o programa é executado. Como posso pará-lo após um intervalo de tempo via bash?

Como alternativa, posso executar este comando em python com o comando os.system ().


Um liner para encontrar processos que estão em execução há mais de 2 horas

ps: comando de instantâneo do processo

-o: inclui apenas colunas especificadas

etimes: tempo decorrido desde o início do processo, em segundos

comando: comando com todos os seus argumentos como uma string

awk: digitalização de padrões e linguagem de processamento

$ 2: segundo token de cada linha (o separador padrão é o espaço)

7200: 7200 segundos = 2 horas

Algo que escrevi alguns anos atrás. Isso procura o nome do aplicativo listado na variável progname e irá eliminá-lo se for mais antigo que o valor na variável killtime (em segundos). Você terá que mudar o progname para coincidir com o nome do processo retornado com ps -o comm. Você também terá que mudar o valor em killtime para coincidir com o número de segundos que você deseja. Pode disparar de um cronjob para inspecionar de vez em quando.

Certifique-se de saber o que tudo isso faz antes de executá-lo ou pode matar processos inesperados.

Isso funciona no RHEL 7.x, então não tenho certeza sobre o Solaris, mas eles são muito próximos, então pode funcionar com poucos ou nenhum ajuste. Se houver erros de formatação, peço desculpas. Tive que limpar alguma bagunça de formatação que sobrou.


Carregando Python na janela Python

A janela Python é um interpretador Python interativo útil para a execução rápida de ferramentas de geoprocessamento ou outros comandos Python. No entanto, o código que já foi escrito e salvo em um script autônomo ou arquivo Python também pode ser carregado na janela Python, modificado e executado. Abaixo está um script simples que examina uma classe de recurso e campo e produz uma lista exclusiva de valores de campo. O exemplo é bastante simples, mas inserir todas as 13 linhas manualmente na janela do Python levaria um tempo considerável. Em vez disso, clicando com o botão direito na janela Python e selecionando Carregar, este código (contido em um script autônomo ou arquivo Python) é imediatamente carregado na janela Python. Depois de carregado na janela Python, as edições podem ser feitas no local da classe de recurso, nome do campo ou sintaxe, e o código pode ser executado pressionando a tecla ENTER com o cursor na última linha do código.

Cria uma lista única de valores de campo com base em uma classe de recurso e nome de campo


12 respostas 12

SVMs Kernelized requerem o cálculo de uma função de distância entre cada ponto no conjunto de dados, que é o custo dominante de $ mathcal(n_ texto vezes n_ text^ 2) $. O armazenamento das distâncias é um fardo na memória, então elas são recalculadas em tempo real. Felizmente, apenas os pontos mais próximos do limite de decisão são necessários na maioria das vezes. As distâncias calculadas com frequência são armazenadas em um cache. Se o cache estiver sendo sobrecarregado, o tempo de execução aumentará para $ mathcal(n_ texto vezes n_ text^3)$.

Você pode aumentar esse cache invocando SVR como

Em geral, isso não vai funcionar. Mas tudo não está perdido. Você pode subamostrar os dados e usar o resto como um conjunto de validação ou pode escolher um modelo diferente. Acima do intervalo de observação de 200.000, é aconselhável escolher aprendizes lineares.

O Kernel SVM pode ser aproximado, aproximando a matriz do kernel e alimentando-o com um SVM linear. Isso permite que você equilibre a precisão e o desempenho no tempo linear.

Um meio popular de conseguir isso é usar cerca de 100 centros de cluster encontrados por kmeans / kmeans ++ como a base de sua função de kernel. Os novos recursos derivados são então alimentados em um modelo linear. Isso funciona muito bem na prática. Ferramentas como sophia-ml e vowpal wabbit são a forma como Google, Yahoo e Microsoft fazem isso. A entrada / saída torna-se o custo dominante para alunos lineares simples.

Na abundância de dados, os modelos não paramétricos desempenham aproximadamente o mesmo para a maioria dos problemas. As exceções são entradas estruturadas, como texto, imagens, séries temporais, áudio.


Solução sugerida

Se você levar em conta que cada número hexagonal também é um número triangular, você pode ignorar os números triangulares completamente:

Minha última solução leva cerca de 50 milissegundos para ser executada na minha máquina.

24 ciclos e leva 6 ciclos para ser concluído e o int de 64 bits é substancialmente mais lento, enquanto o FDIV tem latência de 14-16 ciclos, 4-5 ciclos para ser concluído), e no CPython, o trabalho relacionado ao int é mais caro, pois precisa levar em conta a precisão infinita int s, onde float apenas faz a dupla divisão C bruta. $ endgroup $ & ndash ShadowRanger 5 de setembro de 19 às 16:05

13 ms, com # 1 + # 2 + # 3 caindo para 8,5 ms), uma redução de quase 2/3 no tempo de execução, para código que é (pelo menos para mim) igualmente legível, nenhum código realmente complicado usado apenas para espremer alguns nanossegundos. $ endgroup $ & ndash ShadowRanger 5 de setembro de 19 às 18:53

Variáveis ​​globais não ajudam na legibilidade.

Qual é a diferença entre triângulo e triângulo_number? Esses nomes não me ajudam a entender o que representam.

Uma forma não tem um termo: tem lados. Concretamente, já que estamos falando de formas regulares, ela tem duas propriedades: o número de lados e o comprimento de cada lado. Esta aula não faz sentido para mim.

Se você realmente deseja praticar a estruturação de código com classes, a classe provavelmente deve ser um Solver.

Se você está testando x em ys, então é melhor que ys seja um conjunto, não uma lista, ou você terá que fazer uma pesquisa linear.


1 resposta 1

Na verdade, para responder à sua pergunta, você precisa definir o perfil do seu código. Você precisa entender o que está ocupando todo esse tempo. Só de olhar para o seu código, é impossível dizer, mas meu palpite é que a maior parte do tempo é gasto em um dos seguintes lugares:

Executando todos os arquivos * .csv que você encontra por meio do analisador XML. Tenho a sensação de que você considera isso necessário para descartar arquivos XML que fingem ser arquivos CSV. Idealmente, você deve fazer isso uma vez e, em seguida, rotular corretamente seus arquivos a partir de então, para não ter que fazer essa verificação todas as vezes. Isso me parece uma coisa potencialmente muito cara de se fazer, modifiquei a verificação abaixo para que ela só ocorra quando você estiver realmente interessado no arquivo mais tarde (ou seja, seu caminho contém 'resultados')

Iniciando o processo externo individualmente para cada arquivo que você deseja verificar. O lançamento de processos não é uma operação barata. Idealmente, você deseja iniciar um único processo para cada regra, passando todos os caminhos de arquivo relevantes para que ela verifique todos de uma vez, OU se você escreveu suas regras em Python, pode ler cada arquivo exatamente uma vez e, em seguida, processar através de todas as suas regras de uma vez. Iniciar um novo processo para cada regra, para cada arquivo, é provavelmente uma grande fonte de lentidão.

Existem também várias partes do código que parecem apenas práticas inadequadas. Além disso, se você usa Python 3.5+, pode usar glob em vez de sua função de localização personalizada. No espírito de revisar todo o seu código de qualquer maneira e fazer quaisquer sugestões que pareçam apropriadas, eis como eu sugiro que seu código seja escrito, embora sem nenhuma boa sugestão sobre como acelerar o código (porque, novamente, você DEVE criar um perfil de seu código para entender o que está realmente demorando):


Presumo que você esteja falando sobre os LEDs "on-board" ou "embutidos", e não um LED "add-on" sendo controlado por um pino GPIO. Se for esse o caso, você pode tentar incorporar o seguinte em seu código:

Para o LED PWR (energia), você pode desligá-lo assim:

Parece que você está tentando executar duas partes do seu script ao mesmo tempo. Uma parte está controlando o piscar dos LEDs e a outra parte está executando o resto do código. Isso pode ser feito com multiencadeamento ou multiprocessamento em Python. Olhe para Python 3 threading - paralelismo baseado em thread e multiprocessamento Python 3 - paralelismo baseado em processo.

É possível fazer o que você quiser sem envolver multi-threading ou vários processos separados. Existem méritos em todos esses outros métodos, é claro.

Ok, então como você faz isso? Bem, você precisa instrumentar seu código para atualizar o blink. Funciona um pouco como implementar uma barra de progresso ou registro. Então, imagine que você tem esse código.

É verdade que isso pode se tornar tedioso, mas não necessariamente tão difícil. Obviamente, update_progress () pode verificar um cronômetro de um relógio de parede, para piscar apenas x segundos se for chamado com mais frequência ou apenas deixá-lo alternar toda vez que entrar.

A vantagem desse esquema é que, se o programa principal travar, o mesmo ocorrerá com o flash.


3 respostas 3

O WebIOPi pode ser a melhor solução para você. https://code.google.com/p/webiopi/ Você pode modificar o software de acordo com suas necessidades, mas isso controlará todos os pinos GPIO por meio de uma interface da web. Experimente e veja se funciona para você.

Confira este projeto construído exatamente por este motivo: https://github.com/newbrute/pi-ui

A IU não é pré-configurada e oferece mais flexibilidade do que outras opções por aí

Edit: Para ficar claro, esta é uma solução alternativa e não uma correção para WiringPi.

A função child_process.exec do NodeJS permitirá que você execute um script Python em conjunto com esta opção

Escreva um script php para o seu site. Esta é a página que você verá ao acessar seu pi.

Envie os valores do botão por meio do método POST para o script.

Extraia a mensagem e chame um script python que fará a mudança real no GPIO.

A primeira linha chamaria o script python localizado em / home / pi / path / to / e o executaria. O> / dev / null dirá a ele para colocar toda a saída em um arquivo não existente e o & amp irá executá-lo em segundo plano. Os 2 últimos não são realmente necessários, mas sem eles seu site carregará o tempo que for necessário para executar o script python.

No momento, o php não pôde iniciar o python por causa do comando sudo. É necessário porque precisamos dos privilégios para trabalhar com os Pins GPIO. Portanto, precisamos fazer: sudo nano / etc / sudoers e no final adicionar www-data ALL = (ALL) NOPASSWD: ALL

Escreva um script Python que pegue as variáveis ​​de entrada do php e execute a tarefa.


9 Respostas 9

A proliferação de CPUs multi-core é predominantemente impulsionada pela oferta, não pela demanda.

Você está certo que muitos programadores não se preocupam em decompor seus sistemas para que possam lucrar com vários threads de execução. Portanto, o cliente vê um benefício principalmente na multiprogramação do sistema operacional, em vez da execução do programa multi-thread.

O motivo pelo qual os fornecedores de CPU criam cada vez mais núcleos é que a maneira tradicional de aumentar o desempenho - aumentando a velocidade do clock - esbarra em limitações fundamentais da física (efeitos quânticos e problemas térmicos). Para continuar produzindo chips que podem ser vendidos com credibilidade como oferecendo mais poder de computação do que os chips do ano passado, eles colocaram mais e mais núcleos independentes neles, confiando que a multiprogramação do sistema operacional e o uso crescente de multi-threading irão alcançá-los e render real em vez de apenas ganhos nominais.

Mas não se engane, tanto projetar quanto explorar CPUs multi-core é muito mais difícil do que apenas executar o mesmo código mais rápido. Tanto os programadores quanto os fabricantes de chips gostariam muito de continuar aumentando a velocidade de seus chips; as tendências de paralelização são em grande parte uma questão de necessidade, não de preferência.

Por que o multithreading não está em todos os lugares?

Eu entendo que o multi-threading é difícil de implementar e tem desvantagens se o número de threads for menor do que o esperado.

Por que o multithreading não está em todos os lugares?

Desafio do quadro: mas é em toda parte.

Vamos ver, vamos citar algumas plataformas:

  • Desktops / laptops: uma das aplicações mais comuns hoje é o navegador. E para obter um bom desempenho, os navegadores modernos aproveitam todas as vantagens que podem obter, incluindo multithreading, GPUs, etc. No mínimo, cada guia terá um thread separado. E muitos aplicativos modernos também são construídos em HTML com um navegador integrado (por exemplo, Slack e Discord). Os jogos, pelo menos os maiores, também adotaram o multithreading há muito tempo.
  • Servidores: Hoje em dia, a maioria dos servidores lida com solicitações HTTP de outras tecnologias. E os servidores da Web aumentam muito bem para todos os núcleos que você tem. Claro, cada solicitação provavelmente será executada em um único encadeamento, mas vários encadeamentos significam que você pode processar vários pedidos em paralelo. É absolutamente normal. A outra parte comum - o software de banco de dados - também escala bem e qualquer mecanismo sério usa vários threads.
  • Telefones celulares / tablets: navegadores, novamente. Mas mesmo sem eles, ainda existem muitas tarefas em segundo plano que repetidamente acordam e fazem alguma coisa. Ter vários núcleos significa que essas tarefas em segundo plano afetam menos seu aplicativo em primeiro plano e parece mais & quotsnappy & quot. CPUs de telefones celulares já são bastante potentes, mas o requisito de baixo consumo de energia significa que eles ainda são mais lentos em comparação com os desktops - e ainda assim os usamos talvez ainda mais extensivamente. Incluindo para processos de computação pesada, como jogos.

Para encurtar a história, se voltássemos para CPUs de núcleo único, você notaria imediatamente. Os sistemas operacionais modernos têm muitos processos trabalhando em paralelo e a redução da alternância de tarefas oferece sérios benefícios. Mesmo que alguns programas individualmente tenham poucos benefícios de vários núcleos, o sistema como um todo quase sempre lucra. Dito isso, suponho que haja um limite de quantos núcleos faz sentido ter para vários sistemas. Um telefone celular com 64 núcleos provavelmente não será significativamente mais rápido do que um telefone celular com 32 núcleos.

Quero enfatizar um ponto que você destacou que multithreading é difícil de implementar. Alguns problemas são naturalmente divididos em partes independentes que são facilmente paralelizáveis ​​(& quotembaraçosamente paralelas & quot), portanto, podemos usar facilmente multithreading e outras técnicas paralelas, como instruções vetoriais, sistemas distribuídos, etc. Pode ser tão fácil quanto usar #pragma omp parallel para em um para loop. Talvez até o compilador vetorize automaticamente seu loop.

Muitos problemas não são tão fáceis e exigem muito cuidado na interação entre as diferentes partes para que funcionem na ordem correta e não interrompam o funcionamento uma da outra acidentalmente. Isso é frequentemente implementado com bloqueios que geralmente bloqueiam a execução e podem introduzir deadlock, mas existem algoritmos livres de bloqueio mais exóticos. Mesmo assim, a contenção de recursos compartilhados pode levar a problemas como a escassez de recursos. Consulte o artigo da Wikipedia sobre simultaneidade para uma ampla visão geral que se aplica muito ao multithreading.

O código multithread é muito mais difícil de acertar e muito mais difícil de depurar. Pode haver condições de corrida que só aparecem 1/100 vezes o programa é executado. É muito mais fácil para um programador raciocinar corretamente sobre um programa que (parece) ser executado em ordem do que vários threads em execução com qualquer número de ordens de acesso à memória diferentes. Nos bastidores, um único processador ou compilador pode reordenar as instruções de uma maneira que normalmente fica oculta para o programador, mas interrompe se o multithreading for introduzido.

SEI CERT tem uma lista de regras que devem ser seguidas ao implementar a simultaneidade. Tudo isso deve ser levado em consideração pelo programador para ter código correto, e então o programador também deve considerar o desempenho. Se não for seguido, vulnerabilidades graves de segurança podem seguir.


Como executar um script python no raspberry conectado à Internet através de um script que está sendo executado em algum outro sistema conectado à Internet?

Eu li a abordagem do servidor da Web e experimentei. Isso apenas me mostra o código python de volta no navegador, se eu executar "http: // (endereço IP do meu Pi) /programme.py". Onde o programme.py está na pasta "www" do servidor web.

Eu quero que um programa que lida com o controle de pinos gpio de acordo com minha lógica seja executado no Pi remotamente via Internet e que também a partir de outro script python que está executando em algum outro dispositivo conectado à Internet algo como exec ( "a URL para o programa no Pi") e esse programa no Pi é executado onde meu Pi está conectado à Internet.

Eu tenho um código python no meu laptop e este laptop tem uma conexão com a Internet. Agora, tenho um Pi também e ele tem um código python que trata de controlar os pinos Gpio do Pi e meu Pi também está conectado à Internet. Vou executar esse código no laptop manualmente, mas o código no Pi deve ser executado automaticamente pelo código executado no laptop com a ajuda da Internet, já que ambos os dispositivos estão conectados à Internet. Basicamente, deve ser algo como apenas uma chamada a esse código em Pi para que seja executado. Aqui, os dois códigos são independentes em funcionalidade, a única coisa é que um programa Python precisa apenas iniciar ou iniciar a execução do script no Pi via Internet remotamente.

Não desista do voto Pesquisei muito para fazer isso e tentei muito. Sou muito novo no Pi.


Assista o vídeo: Comment Télécharger et installer Arc GIS