Accélérez l'informatique complexe avec une charge RAM minimale

En train de maîtriser ML, CNN, NN en Python, un novice rencontre presque toujours le problème de la vitesse de calcul, et parfois le manque de RAM.

Cela est particulièrement visible avec les grandes bases de données, dont la taille est supérieure à 50% de la mémoire RAM libre. Penser à acheter du fer plus décent n'est qu'une des solutions possibles.

Une autre option pour utiliser l'une des fonctionnalités de Python est d'itérer sur la fonction elle-même.

Un exemple simple et illustratif. Supposons que vous ayez besoin de créer un nombre de 1 à 10 à 200 000 degrés et d'ajouter leur somme. Par conséquent, vous devriez obtenir un nombre de 200 000 caractères. c'est 2 fois plus que google )

Voici un code simple pour une telle fonction:

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) 

En conséquence, nous obtenons une opération assez «coûteuse» pour votre ordinateur, et par exemple, cela prend plus de 13 ms pour la mienne. Mais que se passe-t-il s'il peut y avoir de nombreuses opérations de ce type? Ensuite, tout devient compliqué, et peut-être que vous n'avez tout simplement pas assez de RAM.

Mais vous pouvez être plus délicat et utiliser exactement la même fonction en exécutant l'itération à travers vos variables.

Voici le code d'une solution aussi simple, de la même fonction:

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

Temps passé sur mon ordinateur



La différence est de 0,13 à 0,024 = 0,106 ms!


Si l'on ajoute simplement 1 à ce nombre énorme de la manière habituelle, alors celui-ci prendra plus de temps que de s'élever au 200 000 degrés. Autrement dit, les avantages de cette méthode sont évidents.

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

Le résultat est le suivant:



Pourquoi Pour autant que je sache, lors de l'itération d'une fonction, Python ne crée pas d'objets temporaires en mémoire, ce qui accélère considérablement tout processus de calcul. Par conséquent, la réécriture de la fonction de cette façon - vous économisez du temps et des nerfs.

Total - pour les calculs complexes avec une taille de mémoire RAM limitée, il est préférable d'utiliser l'itération sur une fonction plutôt que les fonctions elles-mêmes.

J'espère que cela aidera quelqu'un à ne pas perdre de précieuses minutes ou à ne pas dépenser en matériel supplémentaire vieillissant rapidement.

Inspiré par une conférence