Acelere la computación compleja con una carga mínima de RAM

En el proceso de dominar ML, CNN, NN en Python, un novato casi siempre se encuentra con el problema de la velocidad de cálculo y, a veces, la falta de RAM.

Esto es especialmente notable con grandes bases de datos, que son más grandes que el 50% del tamaño de la RAM libre. Pensar en comprar hierro más decente es solo una de las posibles soluciones.

Otra opción para usar una de las características en Python es iterar sobre la función misma.

Un ejemplo simple e ilustrativo. Suponga que necesita construir una serie de números de 200,000 grados del 1 al 10 y agregar su suma. Como resultado, debe obtener un número de 200 mil caracteres. es 2 veces más que google )

Aquí hay un código simple para tal función:

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, obtenemos una operación bastante "costosa" para su computadora y, por ejemplo, la mina demora más de 13 ms. Pero, ¿qué pasa si puede haber muchas de esas operaciones? Entonces todo se complica, y tal vez simplemente no tienes suficiente RAM.

Pero puede ser más complicado y usar exactamente la misma función ejecutando iteraciones a través de sus variables.

Aquí está el código para una solución tan simple, de la misma función:

 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))) 

El tiempo que pasé en mi computadora



¡La diferencia es 0.13 - 0.024 = 0.106 ms!


Si uno simplemente suma 1 a este gran número de la manera habitual, entonces tomará más tiempo que elevarse a 200,000 grados. Es decir, las ventajas de este método son obvias.

 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)))) 

El resultado es este:



Por qué Hasta donde sé, cuando itera sobre una función, Python no crea objetos temporales en la memoria, lo que a su vez acelera significativamente cualquier proceso de cálculo. Por lo tanto, al reescribir la función de esta manera, ahorrará tiempo y nervios.

Total: para cálculos complejos con un tamaño de RAM limitado, es mejor usar la iteración sobre una función que solo las funciones mismas.

Espero que esto ayude a alguien a no perder valiosos minutos o no gastar en hardware adicional que envejece rápidamente.

Inspirado en una conferencia