NumPy Array Arithmetic

1. La puissance de la vectorisation : pourquoi NumPy est-il si rapide ?

Imaginez que vous ayez un million de nombres et que vous souhaitiez calculer l'inverse de chacun. En Python standard, vous utiliseriez probablement une boucle for pour itérer sur chaque nombre. Bien que cela fonctionne, c'est étonnamment lent. Python doit vérifier le type de chaque élément à chaque itération avant d'effectuer l'opération.

NumPy résout ce problème grâce aux opérations vectorisées, implémentées via des "fonctions universelles" (ou ufuncs). Au lieu d'une boucle Python, vous appliquez l'opérateur directement au tableau, et NumPy exécute la boucle en arrière-plan en utilisant du code C pré-compilé et hautement optimisé. La différence de performance est spectaculaire.

Pour bien saisir l'importance de ce concept, je vous invite à lire l'introduction et les deux premières sections de l'article suivant, tiré du Python Data Science Handbook.

Comme vous l'avez lu, passer d'une boucle Python qui prend plusieurs secondes à une opération NumPy qui s'exécute en quelques millisecondes est la raison pour laquelle NumPy est indispensable.

2. Opérations arithmétiques de base

Le plus grand avantage de NumPy est que vous pouvez utiliser les opérateurs arithmétiques standards de Python (+, -, *, /, etc.) directement sur les tableaux. Ces opérations sont appliquées élément par élément.

Opérations entre deux tableaux

Si deux tableaux ont la même forme, les opérations arithmétiques s'effectuent entre les éléments qui se trouvent à la même position.

• a[0] + b[0]
• a[1] + b[1]
• ... et ainsi de suite.

L'image ci-dessous illustre parfaitement ce principe avec deux tableaux, a et b.

Voici comment cela se traduit en code :

import numpy as np

a = np.array([20, 30, 40, 50])
b = np.array([1, 2, 3, 4])




# Addition
c = a + b
print(f"a + b = {c}")  # Affiche [21 32 43 54]




# Soustraction
d = a - b
print(f"a - b = {d}")  # Affiche [19 28 37 46]




# Multiplication
e = a * b
print(f"a * b = {e}")  # Affiche [ 20  60 120 200]




# Division
f = a / b
print(f"a / b = {f}")  # Affiche [20.  15.  13.333... 12.5]

Ces opérations fonctionnent de la même manière pour les tableaux multidimensionnels (matrices), tant qu'ils ont des dimensions identiques.

Opérations avec un scalaire (un seul nombre)

Vous pouvez également effectuer une opération entre un tableau et un seul nombre (un scalaire). Dans ce cas, l'opération est appliquée à chaque élément du tableau. Par exemple, pour convertir une liste de températures de Celsius en Fahrenheit, la formule est $F=C\times 1.8+32$.

temperatures_celsius = np.array([0, 10, 25, 30.5])




# Opération vectorisée
temperatures_fahrenheit = temperatures_celsius * 1.8 + 32

print(f"Températures en Fahrenheit : {temperatures_fahrenheit}")



# Affiche [32.  50.  77.  86.9]

C'est beaucoup plus simple et lisible qu'une boucle for !

Pour un résumé visuel rapide de ces opérations, en particulier entre deux tableaux, cette courte vidéo est très efficace.

3. Autres opérations arithmétiques utiles

NumPy va au-delà des quatre opérations de base et supporte de nombreux autres opérateurs via ses ufuncs.

Le guide officiel de NumPy et le Python Data Science Handbook listent ces opérations de manière exhaustive.

Voici quelques-unes des opérations les plus courantes :

• Exponentiation (**) : Élève chaque élément à une puissance.
• Modulo (%) : Calcule le reste de la division élément par élément. Utile pour déterminer si un nombre est pair ou impair.
• Division entière (//) : Effectue une division et arrondit le résultat à l'entier inférieur le plus proche.

a = np.array([1, 2, 3, 4, 5])




# Exponentiation (au carré)
print(f"a ** 2 = {a ** 2}")  # Affiche [ 1  4  9 16 25]




# Modulo 2 (0 pour les pairs, 1 pour les impairs)
print(f"a % 2 = {a % 2}")  # Affiche [1 0 1 0 1]




# Division entière par 2
print(f"a // 2 = {a // 2}") # Affiche [0 1 1 2 2]

La vidéo suivante explique très bien le fonctionnement du modulo et de la division entière avec des exemples sur des matrices.

Une note importante sur les types de données

Comme NumPy est basé sur C, il est plus strict sur les types de données que Python pur. Si vous essayez d'effectuer une opération qui produit des nombres à virgule (comme une division) et de la stocker dans un tableau qui a été explicitement défini pour ne contenir que des entiers, vous obtiendrez une erreur. C'est une différence majeure avec Python standard. La vidéo de "Python Simplified" que vous venez de regarder aborde ce point crucial juste avant les sections que je vous ai indiquées.

4. Introduction au Broadcasting

Nous avons vu que l'on peut faire tableau + 5. Mais que se passe-t-il si vous essayez d'additionner un tableau de forme (3, 3) et un tableau de forme (3, 1) ? Intuitivement, on pourrait penser que cela ne fonctionne pas. Pourtant, avec NumPy, c'est possible grâce à un mécanisme appelé broadcasting.

Le broadcasting décrit comment NumPy traite les tableaux de formes différentes lors des opérations arithmétiques. Selon certaines règles, le tableau le plus petit est "étiré" ou "diffusé" pour correspondre à la forme du tableau le plus grand. L'opération avec un scalaire est le cas le plus simple de broadcasting.

L'image suivante illustre ce concept.

Nous n'allons pas détailler toutes les règles aujourd'hui, car c'est l'objet de notre prochaine leçon. Retenez simplement que le broadcasting est le mécanisme puissant qui rend les opérations entre tableaux de formes différentes possibles et efficaces.

Exercices pratiques

Mettez vos nouvelles connaissances en pratique !

1. Exercice 1 : Calcul de l'IMC

   • Créez un tableau NumPy poids_kg avec les poids de 5 personnes : [65, 72, 85, 58, 91].
   • Créez un deuxième tableau taille_m avec leurs tailles en mètres : [1.75, 1.80, 1.78, 1.65, 1.90].
   • Calculez l'Indice de Masse Corporelle (IMC) pour chaque personne en utilisant la formule : $\text{IMC}=\frac{\text{poids (kg)}}{{\text{taille (m)}}^2}$.
   • Affichez le tableau des IMC.

2. Exercice 2 : Conversion de devises

   • Vous avez un tableau de prix en euros : prix_eur = np.array([10, 25, 8.50, 150]).
   • Le taux de conversion est de 1.1 dollars pour 1 euro.
   • Créez un tableau prix_usd en convertissant tous les prix en dollars américains.
   • Affichez les deux tableaux.

Solutions

Solution de l'exercice 1 :

import numpy as np

poids_kg = np.array([65, 72, 85, 58, 91])
taille_m = np.array([1.75, 1.80, 1.78, 1.65, 1.90])




# Calcul de l'IMC
# On élève d'abord la taille au carré, puis on divise le poids par ce résultat.
imc = poids_kg / (taille_m ** 2)

print("Tableau des poids (kg):", poids_kg)
print("Tableau des tailles (m):", taille_m)
print("Tableau des IMC calculés:", imc)



# Résultat attendu (approximatif): [21.22 22.22 26.83 21.3  25.19]

Solution de l'exercice 2 :

import numpy as np

prix_eur = np.array([10, 25, 8.50, 150])
taux_conversion = 1.1




# Conversion en USD
prix_usd = prix_eur * taux_conversion

print("Prix en Euros:", prix_eur)
print("Prix en Dollars US:", prix_usd)



# Résultat attendu: [ 11.   27.5   9.35 165. ]

Conclusion

Félicitations ! Vous maîtrisez maintenant l'une des fonctionnalités les plus puissantes de NumPy. Appliquer des opérations mathématiques sur des tableaux entiers sans écrire de boucles est une technique que vous utiliserez constamment en machine learning.

Points clés à retenir :

• Les opérations vectorisées de NumPy utilisent des ufuncs pour exécuter des calculs sur des tableaux entiers beaucoup plus rapidement que les boucles Python.
• Les opérateurs arithmétiques standards (+, -, *, /, **, etc.) fonctionnent élément par élément sur les tableaux NumPy.
• Les opérations peuvent être effectuées entre deux tableaux de même forme ou entre un tableau et un scalaire.
• Le broadcasting est le mécanisme qui permet à NumPy d'effectuer des opérations sur des tableaux de formes différentes (mais compatibles).

Dans la prochaine leçon, nous plongerons dans les détails du broadcasting. Vous apprendrez les règles exactes qui déterminent si deux tableaux sont compatibles pour une opération et comment NumPy les aligne pour effectuer le calcul.