Utiliser la vectorisation pour remplacer les boucles en python

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.

Qu'est-ce que la vectorisation ?

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.

Somme des nombres

##使用循环
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.

Opérations mathématiques

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.

Instructions If-else

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.

Résoudre les réseaux d'apprentissage automatique/d'apprentissage profond

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.

Conclusion

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!