NumPy est en quelque sorte le moteur silencieux qui tourne en arrière-plan des bibliothèques phares comme pandas et scikit-learn. Ces dernières s'appuient sur une structure de données appelée le ndarray, c'est-à-dire un tableau multidimensionnel optimisé.

En Python pur, les boucles for sont souvent un point faible en termes de performance. C'est ici que NumPy brille. Plutôt que de parcourir des listes élément par élément, NumPy nous permet d'effectuer des opérations sur des vecteurs ou des matrices entiers d'un seul coup, ce qu'on appelle la vectorisation. Cela rend le code non seulement plus rapide, mais aussi plus lisible.

Derrière les opérations NumPy se cache du code écrit en langage C. Ce langage est bien plus proche du "métal" de l'ordinateur, c'est-à-dire du matériel, ce qui le rend très performant. Même si C est plus complexe à manier que Python, c'est lui qui fait tout le travail de bas niveau dans NumPy pour que nous puissions profiter d'une exécution ultra-rapide.

Testons maintenant quelques fonctions importantes à connaître.

import numpy as np

np.ones(shape=(4, 3))

Cette commande nous permet de créer une matrice de taille 4 lignes sur 3 colonnes remplie de 1.

A = np.random.randint(0, 10, size=(4, 3))
type(A)
# numpy.ndarray

Ici, on génère une matrice de 4 lignes et 3 colonnes contenant des entiers aléatoires entre 0 et 9. Le type retourné est numpy.ndarray, qui est la structure de base utilisée par NumPy. C'est ce même type que pandas utilise dans ses DataFrames ou que scikit-learn exploite pour entraîner des modèles.

Voyons maintenant la différence entre une simple liste Python et un tableau NumPy. Imaginons que nous ayons une liste de listes comme celle-ci :

liste = [[-3, -3, 4],
         [-1, 0, 1],
         [3, -3, -1],
         [-4, 2, -2]]
type(liste)
# list

Il s'agit ici d'une liste classique de Python, donc peu optimisée pour les opérations mathématiques lourdes. Pour profiter des avantages de NumPy, on peut la convertir en tableau :

B = np.array(liste)
type(B)
# numpy.ndarray

Nous venons ainsi de transformer notre liste en un tableau NumPy. Ce changement de type va nous permettre de faire des opérations mathématiques sur toute la matrice d'un seul coup, de manière ultra-rapide, sans boucles for.

En résumé, pour faire du machine learning en Python, comprendre et utiliser NumPy est indispensable. C'est la base de tout traitement de données performant.

Les attributs essentiels du ndarray

Par ailleurs, lorsqu'on manipule un objet de type numpy.ndarray, on a accès à tout un ensemble d'attributs de classe qui nous permettent de mieux comprendre ou manipuler nos données.

Ces variables nous donnent des informations essentielles sur la structure et le contenu du tableau.

Prenons un exemple simple :

A = np.random.randint(0, 10, size=(4, 3))

Nous avons ici une matrice aléatoire de 4 lignes et 3 colonnes. Une fois créée, nous pouvons consulter plusieurs attributs pour en savoir plus sur cet objet :

shape :

A.shape
# (4, 3)

Cela nous indique que la matrice a 4 lignes et 3 colonnes.

ndim :

A.ndim
# 2

Cet attribut nous informe sur le nombre de dimensions du tableau. Ici, il s'agit d'une matrice bidimensionnelle.

size :

A.size
# 12

On obtient le nombre total d'éléments dans le tableau, ici 4 x 3 = 12.

dtype :

A.dtype
# dtype('int64')

Cette variable nous renseigne sur le type des éléments contenus dans la matrice. Dans ce cas, ce sont des entiers de 64 bits.

Qu'est-ce qu'un entier 64 bits ?

Lorsqu'on parle d'entiers 64 bits, on fait référence à la manière dont les nombres sont représentés en mémoire par l'ordinateur.

Un bit, c'est la plus petite unité d'information en informatique. Il peut prendre uniquement deux valeurs : 0 ou 1. Quand on dit qu'un entier est stocké sur 64 bits, cela signifie que l'ordinateur utilise une suite de 64 zéros et uns pour représenter ce nombre.

Plus un entier est stocké sur un grand nombre de bits, plus on peut représenter une grande plage de valeurs. Par exemple :

  • un entier sur 8 bits (type int8) peut représenter des nombres entre -128 et 127
  • un entier sur 16 bits (type int16) peut aller de -32 768 à 32 767
  • un entier sur 32 bits (type int32) peut aller de -2 147 483 648 à 2 147 483 647
  • un entier sur 64 bits (type int64) permet de représenter des valeurs entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807

C'est donc une question de capacité de stockage de l'information. En machine learning ou en traitement de données, on utilise souvent des int64 ou des float64 (nombres à virgule flottante sur 64 bits) pour éviter les dépassements de capacité, surtout quand on travaille avec de grandes quantités de données.

En résumé, un entier 64 bits, c'est un nombre entier codé en mémoire avec 64 cases binaires. Plus il y a de bits, plus on peut représenter de grands ou de petits nombres.

T :

A.T
# Transpose de la matrice, les lignes deviennent des colonnes et vice versa

La propriété .T retourne la transposée du tableau, ce qui peut être très utile dans les traitements matriciels, notamment en machine learning.

Ainsi, à travers ces quelques variables de classe, NumPy nous donne une vue très riche et précise sur les tableaux que l'on manipule. Ces informations sont fondamentales pour travailler efficacement et en toute clarté avec les données.