Vectorisation en Python

La complexité temporelle de tout algorithme est très importante pour décider si une application est fiable ou non. L`exécution d`un grand algorithme aussi rapidement que possible est très importante lorsqu`il s`agit d`appliquer une sortie en temps réel. Pour ce faire, Python dispose de plusieurs fonctions mathématiques standard pour effectuer rapidement des opérations sur des tableaux entiers de données sans avoir à écrire de boucles. Une telle bibliothèque qui contient une telle fonction est numpy . Voyons comment utiliser cette fonction standard dans le cas de la vectorisation.

Qu`est-ce que la vectorisation ?
La vectorisation est utilisée pour accélérer le code Python sans utiliser de boucle. L`utilisation d`une telle fonction peut aider à minimiser le temps d`exécution de votre code. Diverses opérations sont effectuées sur un vecteur, telles que le produit scalaire des vecteurs, également connu sous le nom de produit scalaire car il produit une sortie unique, les produits externes qui en résultent dans une matrice de mesure carrée. égal à la longueur X de la longueur des vecteurs, multiplication par un élément, qui donne le produit L`élément des indices et la dimension de la matrice restent inchangés.

Nous allons voyez comment les méthodes classiques prennent plus de temps que les fonctions ordinaires, en calculant leur temps de traitement.

outer (a, b) : calcule le produit extérieur de deux vecteurs.
multiplier (a, b) : produit matriciel de deux tableaux.
point (a, b) : produit scalaire de deux tableaux.
zéros ((n, m)) : renvoie une matrice de forme et de type donnés, remplie de zéros.
process_time () : renvoie la valeur (en fractions de seconde) de la somme des temps CPU système et utilisateur du processus en cours. Il n`inclut pas le temps écoulé pendant le sommeil.

Produit scalaire :
Produit scalaire — ; c`est une opération algébrique dans laquelle deux vecteurs de longueur égale sont multipliés pour produire un nombre. Le produit scalaire est souvent appelé produit intérieur . Ce produit donne un nombre scalaire. Considérons deux matrices a et b de même longueur, le produit scalaire est effectué en transposant la première matrice, puis est effectué la multiplication de la matrice mathématique par a ' (transposer a) et b, comme indiqué dans l`image ci-dessous.

Représentation visuelle du produit scalaire —

Ci-dessous voici le code Python :

# Dot product

importer heure

importer numpy

import array

# 8 bytes int

a = array.array ( `q` )

pour i dans plage ( 100000 ):

a.append (i);

b = tableau. tableau ( ` q` )

pour i dans plage ( 100000 , 200000 ) :

b.append (i)

# vecteurs d`implémentation de produits scalaires classiques

tic = time.process_time ()

point = 0.0  ;

pour i dans plage ( len (a)) :

point + = a [i] * b [i]

toc = heure.process_time ()

imprimer ( "dot_product =" + str (point));

print ( "Temps de calcul =" + str ( 1000 * (toc - tic)) + "ms" )

n_tic = temps .process_time ()

n_dot_product = numpy.dot (a, b)

n_toc = heure.process_time ()

print ( "n_dot_product =" + str (n_dot_product))

print ( "Temps de calcul =" + str ( 1000 * (n_toc - n_tic)) + "ms" )

Quitter :

dot_product = 833323333350000.0 Temps de calcul = 35.59449199999999ms n_dot_p roduct = 833323333350000 Temps de calcul = 0,1559900000000225ms 

Produit extérieur :
Produit tenseur de deux vecteurs de coordonnées est appelé Travail externe . Considérons deux vecteurs a et b de dimensions nx 1 et mx 1 puis le produit extérieur du vecteur conduit à une matrice rectangulaire nxm . Si deux vecteurs ont la même dimension, la matrice résultante sera une matrice carrée, comme indiqué sur la figure.

Représentation visuelle du produit externe —

Ci-dessous le code Python :

# Produit extérieur import temps import numpy importer tableau un = array.array ( `i` ) for i in plage ( 200 ) : a.append (je); b = tableau. tableau ( ` i` ) pour i dans range ( 200 , 400 ) : b.append (i) # implémentations classiques de vecteurs de produits externes tic = time.process_time () outer_product = numpy.zeros (( 200 , 200 )) pour je dans range ( len ( a)) : pour j dans range ( len (b)) : outer_product [i] [j] = a [i] * b [j] toc = temps.process_time () print ( "outer_product =" + str (outer_product)); print ( "Temps de calcul =" + str ( 1000 * (toc - tic)) + "ms" ) n_tic = temps.process_time () outer_product = numpy.outer (a, b) n_toc = heure.process_time () imprimer ( "outer_product =" + str (outer_product)) ; print ( "Temps de calcul =" + str ( 1000 * (n_toc - n_tic)) + "ms" ) Quitter : outer_product = [[0. 0. 0. ... , 0. 0. 0.] [200.201.202. ... , 397. 398. 399.] [400. 402. 404. ... , 794. 796. 798.] ..., [39400. 39597. 39794. ... , 78209. 78406. 78603. ] [39600. 39798. 39996. ... , 78606. 78804. 79002.] [39800. 39999. 40198. ... , 79202. 79401.]] Temps de calcul = 39,821617ms produit_extérieur = [[0 0 0 ..., 0 0 0] [200 201 202 ..., 397 398 399] [400 402 404 ..., 794 79 6 798] ..., [39400 39597 39794 ..., 78209 78406 78603] [39600 39798 39996 ..., 78606 78804 79002] [39800 39999 40198 ..., 79003 79202] Temps de calcul = 0,2809480000000031ms Produit élément par élément : Multiplication élément par élément de deux matrices — c`est une opération algébrique dans laquelle chaque élément de la première matrice est multiplié par l`élément correspondant dans la matrice ultérieure. Les dimensions des matrices doivent être les mêmes. Considérons deux matrices a et b, l`indice d`élément dans a — ce sont i et j, alors a (i, j) est multiplié par b (i, j) , respectivement, comme indiqué dans l`image ci-dessous. Représentation visuelle du produit sage Element — Ci-dessous le code Python : # Multiplication élément par élément importer temps importer numpy import tableau a = array.array ( `i` ) pour i dans plage ( 50000 ): a.append (i); b = tableau. tableau ( ` i` ) pour i dans range ( 50000 , 100000 ) : b.append (i) # implémentations classiques de vecteurs de produits article par article vector = numpy.zeros (( 50000 )) tic = temps.process_time () for i in range ( len (a)) : vecteur [i] = a [i] * b [i] toc = temps.process_time () print ( "Element wise Product = " + str (vecteur )); print ( "Temps de calcul =" + str ( 1000 * (toc - tic)) + "ms" ) n_tic = temps .process_time () vecteur = numpy.multiply (a, b) n_toc = heure.process_time () print ( "Element wise Product =" + str (vecteur)); print ( "Temps de calcul =" + str ( 1000 * (n_toc - n_tic)) + "ms" )

Quitter :