Tous les langages de programmation sont indissociables des boucles. Ainsi, par défaut, nous commençons à exécuter une boucle chaque fois qu’il y a une opération répétitive. Mais lorsqu’il s’agit d’un grand nombre d’itérations (millions/milliards de lignes), utiliser des boucles est un crime. Vous pourriez rester bloqué pendant quelques heures, pour vous rendre compte plus tard que cela ne fonctionne pas. C'est là que l'implémentation de la vectorisation en python devient très critique.
La vectorisation est une technique d'implémentation d'opérations de tableau (NumPy) sur un ensemble de données. En coulisse, il applique l'opération à tous les éléments du tableau ou de la série en même temps (contrairement à une boucle "for" qui opère une ligne à la fois).
Ensuite, nous utilisons quelques cas d'utilisation pour démontrer ce qu'est la vectorisation.
##使用循环 import time start = time.time() # iterative sum total = 0 # iterating through 1.5 Million numbers for item in range(0, 1500000): total = total + item print('sum is:' + str(total)) end = time.time() print(end - start) #1124999250000 #0.14 Seconds
## 使用矢量化 import numpy as np start = time.time() # vectorized sum - using numpy for vectorization # np.arange create the sequence of numbers from 0 to 1499999 print(np.sum(np.arange(1500000))) end = time.time() print(end - start) ##1124999250000 ##0.008 Seconds
Le temps d'exécution de la vectorisation est réduit d'environ 18 fois par rapport à l'itération utilisant les fonctions de plage. Cette différence devient encore plus significative lors de l'utilisation de Pandas DataFrame.
En science des données, lorsqu'ils travaillent avec Pandas DataFrame, les développeurs utilisent des boucles pour créer de nouvelles colonnes dérivées via des opérations mathématiques.
Dans l'exemple ci-dessous, nous pouvons voir à quel point il est facile de remplacer les boucles par la vectorisation pour de tels cas d'utilisation.
DataFrame sont des données tabulaires sous forme de lignes et de colonnes.
Nous créons un DataFrame pandas avec 5 millions de lignes et 4 colonnes remplies de valeurs aléatoires entre 0 et 50.
import numpy as np import pandas as pd df = pd.DataFrame(np.random.randint( 0 , 50 , size=( 5000000 , 4 )), columns=( 'a' , 'b' , 'c' , 'd ' )) df.shape # (5000000, 5) df.head()
Créez une nouvelle colonne "ratio" pour trouver le rapport des colonnes "d" et "c".
## 循环遍历 import time start = time.time() # 使用 iterrows 遍历 DataFrame for idx, row in df.iterrows(): # 创建一个新列 df.at[idx, 'ratio' ] = 100 * (row[ "d" ] / row[ "c" ]) end = time.time() print (end - start) ### 109 秒
## 使用矢量化 start = time.time() df[ "ratio" ] = 100 * (df[ "d" ] / df[ "c" ]) end = time.time() print (end - start) ### 0.12 秒
Nous pouvons constater des améliorations significatives avec le DataFrame, l'opération vectorisée étant presque 1000 fois plus rapide par rapport à la boucle en Python.
Nous avons implémenté de nombreuses opérations qui nous obligent à utiliser une logique de type "If-else". On peut facilement remplacer cette logique par des opérations vectorisées en python.
Voyons l'exemple suivant pour mieux le comprendre (nous utiliserons le DataFrame que nous avons créé dans le cas d'utilisation 2) :
Imaginons que nous souhaitions créer une nouvelle colonne basée sur certaines conditions sur la colonne existante "a" Colonne " e"
## 使用循环 import time start = time.time() # 使用 iterrows 遍历 DataFrame for idx, row in df.iterrows(): if row.a == 0 : df.at[idx, 'e' ] = row.d elif ( row.a <= 25 ) & (row.a > 0 ): df.at[idx, 'e' ] = (row.b)-(row.c) else : df.at[idx, 'e' ] = row.b + row.c end = time.time() print (end - start) ### 耗时:166 秒
## 矢量化 start = time.time() df[ 'e' ] = df[ 'b' ] + df[ 'c' ] df.loc[df[ 'a' ] <= 25 , 'e' ] = df [ 'b' ] -df[ 'c' ] df.loc[df[ 'a' ]== 0 , 'e' ] = df[ 'd' ]end = time.time() 打印(结束 - 开始) ## 0.29007707595825195 秒
L'opération vectorisée est 600 fois plus rapide par rapport à une boucle python utilisant des instructions if-else.
L'apprentissage profond nous oblige à résoudre plusieurs équations et problèmes complexes avec des millions et des milliards de lignes à résoudre. Exécuter des boucles pour résoudre ces équations en Python est très lent et la vectorisation est la meilleure solution.
Par exemple, pour calculer les valeurs y pour des millions de lignes dans l'équation de régression linéaire multiple suivante :
Nous pouvons utiliser la vectorisation au lieu de la boucle. Les valeurs de
m1, m2, m3… sont déterminées en résolvant l'équation ci-dessus en utilisant des millions de valeurs correspondant à x1, x2, x3…
import numpy as np # 设置 m 的初始值 m = np.random.rand( 1 , 5 ) # 500 万行的输入值 x = np.random.rand( 5000000 , 5 )
## 使用循环 import numpy as np m = np.random.rand(1,5) x = np.random.rand(5000000,5) total = 0 tic = time.process_time() for i in range(0,5000000): total = 0 for j in range(0,5): total = total + x[i][j]*m[0][j] zer[i] = total toc = time.process_time() print ("Computation time = "+ str ((toc - tic)) + "seconds" ) ####计算时间 = 27.02 秒
## 矢量化 tic = time.process_time() #dot product np.dot(x,mT) toc = time.process_time() print ( "计算时间 = " + str ((toc - tic)) + "seconds" ) ####计算时间 = 0.107 秒
dot implémente. multiplication matricielle vectorisée sur le backend. C'est 165 fois plus rapide que les boucles en Python.
La vectorisation en python est très rapide et doit être préférée aux boucles chaque fois que nous avons affaire à de très grands ensembles de données.
Au fur et à mesure que vous commencerez à le mettre en œuvre au fil du temps, vous vous habituerez à penser selon des lignes de code vectorisées.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!