Acelere a computação complexa com carga mínima de RAM

No processo de dominar ML, CNN, NN em Python, um novato quase sempre encontra o problema da velocidade da computação e, às vezes, a falta de RAM.

Isso é especialmente perceptível em bancos de dados grandes, com tamanho superior a 50% da RAM livre. Pensar em comprar ferro mais decente é apenas uma das soluções possíveis.

Outra opção para usar um dos recursos do Python é iterar sobre a própria função.

Um exemplo simples e ilustrativo. Suponha que você precise construir um número de números de 1 a 10 em 200.000 graus e adicionar sua soma. Como resultado, você deve obter um número com 200 mil caracteres. é 2 vezes mais que o google )

Aqui está um código simples para essa função:

from time import time #    #      def power_1(x): power_1 = 0 start = time() power_1 = x**200000 end = time() total_1 = end - start return round(total_1,6) #   ,         power_1(1) + power_1(2) + power_1(3) + power_1(4) + power_1(5) + power_1(6) + power_1(7) + power_1(8) \ + power_1(9) + power_1(10) 

Como resultado, obtemos uma operação bastante "cara" para o seu computador e, por exemplo, leva mais de 13 ms para o meu. Mas e se houver muitas dessas operações? Então tudo fica complicado, e talvez você simplesmente não tenha RAM suficiente.

Mas você pode ser mais complicado e usar exatamente a mesma função executando iterações nas suas variáveis.

Aqui está o código para uma solução tão simples, da mesma função:

 from time import time #   #   def power_2(): for i in range(11): yield i #     for i in power_2(): if i < 11: d = 0 total_2 = 0 start = time() d += i**200000 end = time() total_2 += end - start print('Ineration {} lasts {}'.format(i, round(total_2, 6))) if i == 10: print(' \n End with total time {} \n'.format(round(total_2,3))) 

Tempo gasto no meu computador



A diferença é de 0,13 - 0,024 = 0,106 ms!


Se alguém simplesmente adicionar 1 a esse grande número da maneira usual, esse processo levará mais tempo do que se elevando ao nível de 200.000. Ou seja, as vantagens desse método são óbvias.

 def add_one(x): total_3 = 0 start = time() s = x + 1 end = time() total_3 += end - start print('Time to do add 1 to BIG number: {} \n'.format(total_3)) return print('Difference in time {}\n'.format(round(total_2 - total_3 ,3))) add_one(d) print('The size of the number {}!!!'.format(len(str(d)))) 

O resultado é este:



Porque Tanto quanto eu sei, ao iterar sobre uma função, o Python não cria objetos temporários na memória, o que, por sua vez, acelera significativamente qualquer processo de cálculo. Portanto, reescrevendo a função dessa maneira - você economiza tempo e nervos.

Total - para cálculos complexos com tamanho limitado de RAM, é melhor usar a iteração sobre uma função do que apenas as próprias funções.

Espero que isso ajude alguém a não perder minutos preciosos ou a não gastar em hardware adicional que envelhece rapidamente.

Inspirado por uma palestra