Creation de modèles d'IA avec Python
Pre-réquis:
- Comprendre les bases de l'IA et de l'apprentissage automatique
- Se familiariser avec les algorithmes d'apprentissage automatique
- Configuration de l'environment de Travail
- Concepts de bases en Python
Les outils utilisés dans ce tutoriel
Jupyter Notebook :
- Description : Jupyter Notebook est un environnement interactif de développement qui permet d'écrire et d'exécuter du code en segments appelés cellules. Il est largement utilisé dans le domaine de la science des données et de l'apprentissage automatique pour créer des documents intégrant du code, des textes, des images et des visualisations.
- Avantages : Facilite l'expérimentation, la visualisation interactive des résultats, et encourage la documentation en temps réel du code.
Venv (Virtual Environment) :
- Description : Venv est un outil Python intégré permettant de créer des environnements virtuels isolés pour un projet spécifique. Il aide à gérer les dépendances et à éviter les conflits entre différentes versions de bibliothèques pour différents projets Python.
- Avantages : Isolation des dépendances, facilité de gestion des environnements pour différents projets, prévention des conflits entre versions de bibliothèques.
NumPy :
- Description : NumPy est une bibliothèque fondamentale pour le calcul scientifique en Python. Elle offre des structures de données puissantes, notamment des tableaux multidimensionnels (ndarray), et des fonctions mathématiques pour effectuer des opérations rapides sur ces tableaux.
- Avantages : Manipulation efficace des tableaux, performances optimisées pour les calculs numériques, intégration transparente avec d'autres bibliothèques de calcul scientifique.
Matplotlib :
- Description : Matplotlib est une bibliothèque de visualisation en 2D pour Python. Elle permet de créer des graphiques, des diagrammes et des visualisations de données de manière simple et flexible. Matplotlib est souvent utilisé en conjonction avec NumPy et Jupyter Notebook pour explorer visuellement les résultats.
- Avantages : Grande flexibilité dans la création de graphiques, support pour divers types de visualisations, compatibilité avec Jupyter Notebook.
Seaborn :
- Description : Seaborn est une bibliothèque de visualisation de données en Python basée sur Matplotlib. Elle simplifie la création de graphiques statistiques informatifs en fournissant des interfaces haut niveau pour dessiner des diagrammes tels que des graphiques en barres, des diagrammes en boîte et des diagrammes de dispersion avec des palettes de couleurs attrayantes.
- Avantages : Création simple de visualisations statistiques, palettes de couleurs esthétiques, intégration transparente avec les DataFrames Pandas.
Pandas :
- Description : Pandas est une bibliothèque destinée à la manipulation et à l'analyse de données en Python. Elle offre des structures de données performantes (notamment les DataFrames) pour faciliter le nettoyage, la transformation, l'agrégation et l'analyse de données tabulaires.
- Avantages : Traitement efficace des données tabulaires, outils puissants pour la manipulation et l'analyse de données, intégration transparente avec d'autres bibliothèques.
Scikit-learn :
- Description : Scikit-learn est une bibliothèque d'apprentissage automatique en Python qui propose des outils simples et efficaces pour la classification, la régression, le clustering, la réduction de dimension, et bien d'autres tâches. Elle s'intègre bien avec NumPy, Pandas et Matplotlib.
- Avantages : Facilité d'utilisation, documentation exhaustive, grande variété d'algorithmes d'apprentissage automatique.
Préparation de l'environmment de Travail
1- Configuration de l'environnement de travail
2- Configuration d'un environmement virtuel avec Venv
- Pourquoi un environnement virtuel ?
- Imaginez que vous construisez une maison. Vous avez besoin de différents outils et matériaux pour chaque étape de la construction : marteaux, clous, briques, etc. Si vous mélangez tous ces outils et matériaux dans un seul endroit, il sera difficile de trouver ce dont vous avez besoin et de travailler efficacement.
C'est la même chose pour le développement d'IA en Python. Vous avez besoin de différentes bibliothèques et modules pour différents projets. Si vous installez toutes ces bibliothèques dans votre environnement Python principal, cela peut créer des conflits et des problèmes de compatibilité.
Un environnement virtuel est comme un espace de travail séparé pour chaque projet. Il vous permet d'installer les bibliothèques et les modules dont vous avez besoin pour ce projet spécifique, sans affecter votre environnement Python principal.
Venv : Il s'agit d'un module intégré à la bibliothèque standard de Python à partir de la version 3.3. Bien qu'il soit plus récent que Virtualenv, il offre des fonctionnalités similaires.
Virtualenv : C'est un package externe qui existe depuis plus longtemps. Il était largement utilisé avant que Venv ne soit inclus dans la bibliothèque standard de Python.
Dans ce tutoriel, nous allons utiliser Venv. Si pour une raison ou une autre, vous souhaitez utiliser Virtualenv, vous devez d'abord l'installer en utilisant la commande suivante dans votre terminal : pip install virtualenv ou python -m pip install --user vitrualenv
- Création d'un environnement virtuel avec Venv
Ouvrir l'invite de commande ou PowerShell:
- Faites un clic droit sur votre dossier de travail (Atelier_AEBM_IA), puis sélectionnez "Copier le chemin". Vous pouvez également sélectionner le dossier, puis utilisez Ctrl+Shift+C pour obtenir le même résultat.
- Dans l'invite de commande ou PowerShell, tapez
cdsuivi du chemin copié (par exemple :cd C:\Users\etiab\Desktop\Atelier_AEBM_IA). Ceci vous permet de vous deplacer dans votre dossier de travail.
Créer l'environnement virtuel:
- Choisissez un nom pour votre environnement virtuel (par exemple : "tuto_IA").
- Tapez la commande suivante pour créer l'environnement :
python -m venv .tuto_IA
Si vous utilisez Virtualenv à la place de Venv, tapez plutôt :
python -m virtualenv .tuto_IA- Activer et Désactiver l'environnement virtuel
Naviguez dans votre dossier de travail si vous n'y etes pas (avec la commande cd vue précédemment), puis tapez la commande suivante pour activer l'environnement virtuel :
.\.tuto_IA\Scripts\activate
Remplacez "tuto_IA" par le nom de votre environnement virtuel.
- Désactiver l'environnement virtuel
deactivate3- Installation des bibliothèques IA
Assurez-vous d'avoir activé l'environnement virtuel avant d'installer les bibliothèques.
Pour installer une bibliothèque, utilisez le gestionnaire de paquets pip et la commande install suivie du nom de la bibliothèque.
Par exemple, pour installer la bibliothèque numpy, tapez :
pip install numpy
En cas d'échec de l'installation, recherchez sur internet comment installer la bibliothèque avec les bonnes configurations.
Pour installer les bibliothèques mentionnées dans ce tutoriel :Numpy : pip install numpy
pip install matplotlibpip install seabornpip install pandaspip install scikit-learnVous pouvez également installer plusieurs bibliothèques en une seule fois en les séparant par des espaces :
pip install numpy matplotlib seaborn pandas scikit-learn
Notez que l'installation groupée est pratique pour gagner du temps.
En cas d'échec d'installation, recherchez sur internet comment installer la bibliothèque spécifique avec les configurations appropriées. (Utilisez par exemple la requête : "comment installer bibliothèqueXY").
En suivant ces étapes, vous créez un environnement virtuel isolé et installez les bibliothèques requises pour votre projet IA.
Remarque: Pour utiliser Jupyter Notebook dans votre environnement virtuel, vous devez installer la bibliothèque suivante :
- Ipykernel :
pip install ipykernel
Prise en main des bibliothèques installées
Bibliothèque : nom_de_la_bibliothèque
│
├── Module : nom_du_module
│ ├── Fonction : nom_de_la_fonction
│ └── Fonction : ...
│
├── Module : ...
└── Module : ...
Les fonctions, modules et bibliothèques sont les blocs de construction de vos programmes Python.
Utilisation des bibliothèques
Démarrage d'un notebook Jupyter dans Visual Studio Code
1. Ouvrir Visual Studio Code et votre dossier de travail
- Lancez Visual Studio Code.
- Ouvrez votre dossier de travail en cliquant sur Fichier > Ouvrir un dossier.
2. Créer un nouveau fichier notebook
- Cliquez sur Fichier > Nouveau fichier.
- Enregistrez le fichier avec l'extension .ipynb. Par exemple, "mon_premier_notebook.ipynb".
3. Choisir le moteur d'exécution (kernel) - Voir captures
Un notebook Jupyter est un outil interactif qui permet d'exécuter du code, d'afficher des résultats et de mélanger du texte et des images dans un seul document.
Il est composé de cellules, qui sont des blocs de code ou de texte.
Pour créer une nouvelle cellule, survolez la cellule existante avec le curseur en allant vers le bas. Vous verrez deux options : 1-code, 2-Markdown, comme illustré dans la capture ci-dessous :
Si votre cellule est destinée à recevoir du code Python, choisissez l'option 1. Sinon, s'il s'agit d'écrire du texte ou toute autre chose, choisissez l'option 2.
Importer une bibliothèque
Voici comment importer une bibliothèque en Python :
- Ouvrez votre script Python (Par exemple le notebook que vous avez créer).
- Ajoutez la ligne suivante au début de votre script : import nom_de_la_bibliotheque
Par exemple, pour importer la bibliothèque "numpy", il vous suffit de vous tapez : import numpy
Une fois la bibliothèque importée, vous pouvez utiliser ses fonctions et ses modules.
Voici quelques exemples (Creer une nouvelle cellue pour chaque exemple):
- Pour afficher la version de la bibliothèque "numpy" :
import numpy #ceci permet d'importer numpy
print(numpy.__version__) # affichage la version de numpy- Pour créer un liste de nombres avec la bibliothèque "numpy" :
import numpy
array = numpy.array([1, 2, 3])
print(array)Les alias ou renommation des bibliothèques
L'utilisation d'alias ou la renommation des bibliothèques en Python est une pratique courante pour simplifier le code et améliorer la lisibilité.
Il peut être utile de renommer une bibliothèque pour :
- Raccourcir le nom.
- Éviter les conflits de noms avec d'autres bibliothèques.
- Rendre le code plus lisible.
import numpy as np # np est maintenant un alias de numpy
Pratiques: Importer les autres bibliothèques que vous avez installé et affichez leurs versions
Importer des modules et fonctions spécifiques
Pour importer des modules et fonctions spécifiques, on utilise le mot-clé
from suivi du nom du module et d'une liste des éléments à importer. La syntaxe est la suivante :from <nom_module> import <nom_fonction1>, <nom_fonction2>, ...Prenons l'exemple de la bibliothèque NumPy, qui propose un grand nombre de fonctions pour la manipulation de tableaux (listes) de données. Supposons que nous avons besoin uniquement des fonctions array et sum. Voici comment les importer :
from numpy import array, sum
# Créer un tableau NumPy
x = array([1, 2, 3, 4])
# Calculer la somme des éléments du tableau
total = sum(x)
print(total) # Affiche 10Avantages de l'importation sélective- Lisbilité accrue: Le code est plus clair et plus facile à comprendre car il ne contient que les éléments nécessaires.
- Efficacité accrue: Le temps de chargement du code est réduit car seuls les modules et fonctions utilisés sont importés.
- Modularité accrue: Le code est plus modulaire et peut être plus facilement réutilisé dans d'autres projets.
- Lisbilité accrue: Le code est plus clair et plus facile à comprendre car il ne contient que les éléments nécessaires.
- Efficacité accrue: Le temps de chargement du code est réduit car seuls les modules et fonctions utilisés sont importés.
- Modularité accrue: Le code est plus modulaire et peut être plus facilement réutilisé dans d'autres projets.
L'Iris est une fleur aux multiples variétés, et notre objectif est de construire un modèle capable de discerner ces variétés en fonction de certaines caractéristiques telles que la longueur et la largeur des pétales et des sépales. Ce projet pratique servira de fil conducteur pour comprendre comment créer, entraîner et évaluer des modèles de classification, et cela même si vous êtes un débutant enthousiaste dans le domaine de l'IA.
Pour accomplir cette mission, nous suivrons les étapes suivantes :
Étape 1 : Comprendre le Jeu de Données Iris
Il existe 3 espèces de fleurs d'iris dans le dataset : Iris setosa, Iris versicolor et Iris virginica
- Un identifiant unique (Id)
- La longueur de ses sépales (sepal length)
- La largeur de ses sépales (sepal width)
- La longueur de ses pétales (petal length)
- La largeur de ses pétales (petal length)
- Son espèce (species)
Pour charger et visualiser ce jeu de données, suivez ces étapes préliminaires : 1. Téléchargez le jeu de données en cliquant ici 👉 Lien de Téléchargement
2. Déplacez le fichier téléchargé "Iris.csv" dans votre dossier de travail. Notez que votre navigateur peut télécharger le fichier au format compressé. Dans ce cas, assurez-vous de décompresser (extraire) le fichier avant de le déplacer dans votre dossier de travail.
3. Lancez VSCode et ouvrez votre dossier de travail (si ce n'est pas déjà fait).
4. Créez un nouveau fichier notebook avec l'extension ".ipynb". Par exemple : mon_premier_ia.ipynb.
5. Activez votre environnement virtuel en sélectionnant le noyau (kernel) dont le nom correspond à l'environnement virtuel que vous avez créé. Une fois le fichier notebook créé et l'environnement virtuel activé, vous êtes prêt(e) à charger et explorer les données.
Étape 2 : Charger et Explorer les Données
Chargez le jeu de données Iris en utilisant la bibliothèque pandas et explorez les premières lignes pour comprendre la structure. Identifiez les caractéristiques (features) et la variable cible (target) que vous prévoyez de prédire. Pour effectuer le chargement des données, nous utiliserons la bibliothèque pandas. Créez une cellule et ajoutez-y le code suivant (Assurez-vous que le fichier "Iris.csv" est dans le même répertoire que votre fichier Python) :
# 1. Importer la bibliothèque Pandas et renommé en pd
import pandas as pd
# 2. Charger le dataset Iris.csv
dataset = pd.read_csv("Iris.csv")
# 3. Afficher les premières lignes du dataset
dataset.head()Vous deviez voir quelques choise comme ça:
| Id | SepalLengthCm | SepalWidthCm | PetalLengthCm | PetalWidthCm | Species |
|---|---|---|---|---|---|
| 1 | 5.1 | 3.5 | 1.4 | 0.2 | setosa |
| 2 | 4.9 | 3.0 | 1.4 | 0.2 | setosa |
| 3 | 4.7 | 3.2 | 1.3 | 0.2 | setosa |
| 4 | 4.6 | 3.1 | 1.5 | 0.2 | setosa |
| 5 | 5.0 | 3.6 | 1.4 | 0.2 | setosa |
Vous pouvez egalement voir les derniers lignes en utilisant le code suivant (dans une nouvelle cellule evidemement)
# 3. Afficher les dernières lignes du dataset
dataset.tail()print(dataset)Notez que l'affciage serà tronquée par le script pour economiser de l'espcae.
Pour un apercu general sur l'enemble des données l'ensemble des données, utilisez:
dataset.info()Ceci pour vous permettra d'obtenir un aperçu général du dataset, incluant ses dimensions, types de données, et valeurs nulles.
Résumez les statistiques descriptives des variables numériques:
print(dataset.describe())D'autres explorations:
# Explorez les distributions des variables
dataset.hist(figsize=(10, 6))
# Examinez les relations entre variables: la matrice de correlation
dataset.corr()Vous pouvez consulter la documentation de pandas ici 👉 https://pandas.pydata.org/docs/ pour plus d'options.
Étape 3 : Visualizer les Données
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd# Chargement des données
dataset = pd.read_csv("Iris.csv")# Pairplot pour visualiser les relations entre les caractéristiques
sns.pairplot(dataset, hue='Species', height=2.5)
plt.show()# Boîte à moustaches pour chaque caractéristique
plt.figure(figsize=(12, 8))
for i, feature in enumerate(dataset.columns[1:-1]):
plt.subplot(2, 2, i+1)
sns.boxplot(x='Species', y=feature, data=data)
plt.title(f'{feature} Distribution by Class')
plt.tight_layout()
plt.show()
# Matrice de corrélation pour évaluer les relations entre les caractéristiques
plt.figure(figsize=(10, 8))
sns.heatmap(dataset.corr(), annot=True, cmap='coolwarm', linewidths=.5)
plt.title('Matrice de Corrélation')
plt.show()Cette étape de visualisation vous permettra d'obtenir des informations cruciales sur la distribution des caractéristiques et les relations entre les différentes classes dans le jeu de données Iris. N'hésitez pas à explorer davantage pour mieux comprendre la structure des données.
Remarques : L'exploration et la visualisation des données visent à acquérir une compréhension approfondie du jeu de données, ce qui permet ensuite une meilleure préparation avant l'entraînement d'un modèle de manière efficace. Ce sont des étapes cruciales dans le processus d'apprentissage automatique et permettent en général de :
- Comprendre la structure et les caractéristiques des données.
- Identifier d'éventuelles anomalies ou incohérences.
- Détecter des relations et des structures cachées.
- Sélectionner les variables les plus pertinentes pour le modèle.
- Choisir la méthode de préparation des données la plus appropriée.
Étape 4 : Préparer les Données
La préparation des données est essentielle pour garantir que votre modèle d'IA peut apprendre efficacement à partir des données disponibles. Dans cette étape, nous allons diviser les données en ensembles d'entraînement et de test, et standardiser les caractéristiques. Pour ça, nous allons utiliser scikit-learn, une bibliothèque populaire pour l'apprentissage automatique en Python.
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler# Supprimer la colonne 'Id' si elle existe en decommentant la ligne suivante
# dataset = dataset.drop('Id', axis=1)
# Diviser les données en caractéristiques (X) et variable cible (y)
X = dataset.drop('Species', axis=1)
y = dataset['Species']# Diviser les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# Standardiser les caractéristiques pour une meilleure performance du modèle
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)Explication :
train_test_split : Cette fonction divise les données en ensembles d'entraînement et de test. L'argument test_size=0.3 indique que 30% des données seront utilisées pour le test.StandardScaler : Cet outil standardise les caractéristiques en ajustant la moyenne à zéro et l'écart-type à un. Cela garantit que toutes les caractéristiques ont la même échelle, ce qui est important pour certains algorithmes.Cette étape garantit que les données sont prêtes pour être utilisées dans le modèle, en assurant une comparabilité entre les différentes caractéristiques. La standardisation est particulièrement importante pour les algorithmes sensibles à l'échelle des caractéristiques, comme les k-NN.
Étape 5 : Construire le Modèle
Nous allons maintenant utiliser l'algorithme des k plus proches voisins (K-NN) pour construire notre premier modèle d'IA. Scikit-learn facilite grandement ce processus.
from sklearn.neighbors import KNeighborsClassifier# Initialiser le modèle K-NN
model = KNeighborsClassifier(n_neighbors=3)# Entraîner le modèle sur les données d'entraînement
model.fit(X_train, y_train)# Faire des prédictions sur les données de test
predictions = model.predict(X_test)Explication :KNeighborsClassifier : C'est le modèle K-NN. L'argument n_neighbors=3 indique que le modèle considérera les 3 voisins les plus proches pour faire une prédiction.
fit : Cette méthode entraîne le modèle sur les données d'entraînement.
predict : Cette méthode génère des prédictions sur les données de test.
Avec ces quelques lignes de code, vous avez construit et entraîné un modèle K-NN. Passons à l'étape suivante pour évaluer la performance de notre modèle. Étape 6 : Évaluer le Modèle et Visualiser les Résultats
Après avoir construit et entraîné notre modèle K-NN, évaluons sa performance sur les données de test.
KNeighborsClassifier: C'est le modèle K-NN. L'argumentn_neighbors=3indique que le modèle considérera les 3 voisins les plus proches pour faire une prédiction.
fit: Cette méthode entraîne le modèle sur les données d'entraînement.
predict: Cette méthode génère des prédictions sur les données de test.
Étape 6 : Évaluer le Modèle et Visualiser les Résultats
Après avoir construit et entraîné notre modèle K-NN, évaluons sa performance sur les données de test.from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
# Évaluer la précision du modèle
accuracy = accuracy_score(y_test, predictions)
print(f'Précision du modèle K-NN : {accuracy:.2%}\n')
# Afficher le rapport de classification
print('Rapport de Classification :\n', classification_report(y_test, predictions))
# Afficher la matrice de confusion
conf_matrix = confusion_matrix(y_test, predictions)
print('Matrice de Confusion :\n', conf_matrix)
accuracy_score: Cette fonction mesure la précision du modèle en comparant les prédictions aux vraies valeurs.
classification_report: Fournit un rapport détaillé incluant la précision, le rappel et le score F1 pour chaque classe.
confusion_matrix: Affiche une matrice montrant les vrais positifs, vrais négatifs, faux positifs et faux négatifs.
Ces évaluations vous donneront un aperçu complet de la performance du modèle. Continuez à affiner et à améliorer votre modèle en fonction des résultats obtenus.
Voilà ! Vous avez maintenant créé votre premier modèle d'IA sur le dataset Iris. N'hésitez pas à explorer davantage en ajustant les paramètres du modèle ou en essayant d'autres algorithmes.
Happy coding!
Étape Bonus : Comparaison de Plusieurs Modèles de Classification
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
# Initialiser différents modèles
models = {
'K-NN': KNeighborsClassifier(n_neighbors=3),
'SVM': SVC(),
'Arbre de Décision': DecisionTreeClassifier(),
'Forêt Aléatoire': RandomForestClassifier(),
'Régression Logistique': LogisticRegression()
}
# Évaluer et comparer les performances de chaque modèle
for name, model in models.items():
model.fit(X_train, y_train)
predictions = model.predict(X_test)
# Mesurer la précision
accuracy = accuracy_score(y_test, predictions)
print(f'Précision du modèle {name} : {accuracy:.2%}')
# Afficher le rapport de classification
print(f'Rapport de Classification {name} :\n', classification_report(y_test, predictions))
# Afficher la matrice de confusion
conf_matrix = confusion_matrix(y_test, predictions)
print(f'Matrice de Confusion {name} :\n', conf_matrix)
print('\n' + '-'*50 + '\n')
-- Nous avons créé un dictionnaire
models qui contient différents modèles de classification, chacun étant initialisé avec ses paramètres par défaut. Les modèles inclus sont le K-NN, le SVM, l'Arbre de Décision, la Forêt Aléatoire, et la Régression Logistique.--Nous avons ensuite utilisé une boucle
for pour itérer à travers chaque modèle du dictionnaire. Pour chaque modèle, nous l'avons entraîné sur les données d'entraînement, fait des prédictions sur les données de test, puis mesuré et affiché sa précision, son rapport de classification, et sa matrice de confusion.En plus, voici comment vous pourriez organiser les résultats dans un tableau comparatif des performances des différents modèles :
import pandas as pd
# Initialiser un dictionnaire pour stocker les résultats
results = {'Modèle': [], 'Précision': [], 'Rappel': [], 'F1-Score': []}
# Entrainer, Évaluer et stocker les performances de chaque modèle
for name, model in models.items():
model.fit(X_train, y_train)
predictions = model.predict(X_test)
# Mesurer la précision, le rappel et le score F1
accuracy = accuracy_score(y_test, predictions)
report = classification_report(y_test, predictions, output_dict=True)
# Stocker les résultats dans le dictionnaire
results['Modèle'].append(name)
results['Précision'].append(accuracy)
results['Rappel'].append(report['weighted avg']['recall'])
results['F1-Score'].append(report['weighted avg']['f1-score'])
# Créer un DataFrame à partir des résultats
results_df = pd.DataFrame(results)
# Stocker au format csv
# results_df.to_csv("results_df.csv", index=False)
# Afficher le tableau comparatif
print(results_df)
Documentation des bibliothèques Python pour la science des données
- Documentation officielle: https://numpy.org/doc/
- Tutoriel: https://docs.scipy.org/
- Documentation officielle: https://matplotlib.org/stable/index.html
- Documentation officielle: https://seaborn.pydata.org/
- Tutoriel: https://seaborn.pydata.org/tutorial.html
- Documentation officielle: https://pandas.pydata.org/docs/
- Documentation officielle: https://scikit-learn.org/0.21/documentation.html
Ces bibliothèques sont essentielles pour la science des données et l'apprentissage automatique en Python. Leur maîtrise vous permettra de manipuler, analyser et visualiser des données efficacement.