Premiers pas avec l'apprentissage automatique en Python

Python est l'un des langages de programmation les plus couramment utilisés en apprentissage automatique, en raison de sa facilité d'apprentissage, de son riche support de bibliothèques et de son écosystème communautaire.

Ensuite, je vais expliquer étape par étape comment débuter en apprentissage automatique avec Python, et présenter quelques bibliothèques courantes dont vous aurez besoin.

Installation de Python et des bibliothèques nécessaires

Méthode 1 : installateur officiel

Tout d'abord, assurez-vous d'avoir installé Python. Vous pouvez visiter le site officiel de Pythonhttps://www.python.org/pour télécharger et installer la dernière version.

Système Windows :

# 1. 下载安装程序后运行
# 2. 勾选 "Add Python to PATH"
# 3. 选择 "Install for all users"
# 4. 点击 "Install" 开始安装

Système macOS :

# 方法1：使用官网安装包
# 下载 .pkg 文件并双击安装
# 方法2：使用 Homebrew
brew install python3

Système Linux :

# Ubuntu/Debian
sudo apt update
sudo apt install python3 python3-pip
# CentOS/RHEL
sudo yum install python3 python3-pip

Méthode 2 : distribution Anaconda

Anaconda est une distribution Python conçue spécifiquement pour la science des données, comme une "boîte à outils d'apprentissage automatique" avec tous les outils préinstallés.

Avantages d'Anaconda

Bibliothèques courantes préinstallées: NumPy, Pandas, Scikit-learn, etc.
Gestion des environnements: les commandes conda gèrent les environnements virtuels
Interface graphique: Anaconda Navigator fournit des opérations visuelles
Multiplateforme: Prend en charge tous les principaux systèmes d'exploitation

Installer Anaconda

Visitezhttps://www.anaconda.com/products/distribution
Téléchargez le paquet d'installation pour votre système
Lancez l'installateur et suivez les instructions pour terminer l'installation

Vérifiez l'installation :

conda --version
python --version

Si vous n'êtes pas encore à l'aise avec Python, vous pouvez d'abord étudier notreTutoriel Python。

Si vous n'êtes pas encore à l'aise avec Conda, vous pouvez d'abord étudier notreTutoriel Anaconda。

Il est recommandé d'installer Anaconda pour créer des environnements virtuels.

Pourquoi avez-vous besoin d'environnements virtuels ?

Un environnement virtuel est comme une cuisine indépendante préparée pour chaque projet, empêchant les « assaisonnements » (versions de bibliothèques) de différents projets d'interférer les uns avec les autres.

Avantages des environnements virtuels

Isolation des dépendances: Différents projets utilisent différentes versions de bibliothèques
Reproductibilité de l'environnement: Recréer facilement le même environnement sur d'autres machines
Gestion des permissions: Éviter de polluer l'environnement Python du système
Nettoyage du projet: Supprimez l'environnement associé lors de la suppression du projet

Gestion des environnements avec conda

# 创建环境
conda create -n ml_env python=3.8
# 激活环境
conda activate ml_env
# 安装包
conda install numpy pandas scikit-learn
# 列出环境
conda env list
# 删除环境
conda env remove -n ml_env

Configuration des outils de développement

Jupyter Notebook

Jupyter Notebook est un laboratoire numérique pour les spécialistes des données, qui prend en charge la programmation interactive et la présentation visuelle.

Installation et démarrage de Jupyter

# 安装 Jupyter
pip install jupyter
# 启动 Jupyter Notebook
jupyter notebook
# 启动 Jupyter Lab（更现代的界面）
jupyter lab

Utilisation de base de Jupyter

Exemple

# Exemple d'utilisation de Jupyter Notebook
# Exécuter le code suivant dans Jupyter
# 1. Importation et exploration des données
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# Créer des données d'exemple
data = {
'Name': ['Zhang San', 'Li Si', 'Wang Wu', 'Zhao Liu'],
'Age': [25, 30, 35, 28],
'Ville': ['Pékin', 'Shanghai', 'Canton', 'Shenzhen'],
'Salary': [15000, 20000, 18000, 22000]
}
df = pd.DataFrame(data)
print("Aperçu des données :")
print(df.head())
# 2. Visualisation des données
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.bar(df['Name'], df['Age'])
plt.title('Age distribution')
plt.xlabel('Name')
plt.ylabel('Âge')
plt.subplot(1, 2, 2)
plt.bar(df['Name'], df['Salary'])
plt.title('Répartition des salaires')
plt.xlabel('Name')
plt.ylabel('Salaire')
plt.tight_layout()
plt.show()
# 3. Analyse statistique simple
print("\n"Informations statistiques de base :")
print(df.describe())
print("\n"Répartition par ville :")
print(df['City'].value_counts())

Configuration de VS Code

VS Code est un éditeur de code léger mais puissant, et grâce aux plugins, il peut devenir un environnement de développement professionnel pour l'apprentissage automatique.

Plugins recommandés

Python: plugin Python officiel de Microsoft
Jupyter: Prend en charge Jupyter Notebook
Générateur de docstrings Python: Générer automatiquement des docstrings
Bracket Pair Colorizer: Colorisation des paires de crochets
GitLens: Améliorer les fonctionnalités Git

Exemple de configuration VS Code

// .vscode/settings.json
{
    "python.defaultInterpreterPath": "./envs/ml_env/bin/python",
    "python.linting.enabled": true,
    "python.linting.pylintEnabled": true,
    "python.formatting.provider": "black",
    "python.testing.pytestEnabled": true,
    "jupyter.askForKernelRestart": false,
    "editor.fontSize": 14,
    "editor.tabSize": 4,
    "editor.insertSpaces": true
}

Installation des bibliothèques d'apprentissage automatique

Bibliothèques d'apprentissage automatique courantes :

pip install numpy pandas matplotlib seaborn scikit-learn

Si vous prévoyez d'utiliser un framework d'apprentissage profond, installez ce qui suit :

pip install torch  # 或者
pip install tensorflow

Cours associés :

Lorsque vous utilisez Python pour l'apprentissage automatique, le processus complet suit généralement ces étapes :

Importer les bibliothèques nécessaires- Par exemple, NumPy, Pandas et Scikit-learn.
Charger et préparer les données- Les données sont au cœur de l'apprentissage automatique. Vous devez charger les données et effectuer le prétraitement nécessaire (par exemple, nettoyage des données, imputation des valeurs manquantes, etc.).
Sélectionner des modèles et des algorithmes- Sélectionner des algorithmes d'apprentissage automatique adaptés à la tâche (par exemple, régression linéaire, arbres de décision, etc.).
Entraîner le modèle- Utiliser les données de l'ensemble d'entraînement pour entraîner le modèle.
Évaluer le modèle- Utiliser l'ensemble de test pour évaluer la précision du modèle et optimiser le modèle en fonction des résultats de l'évaluation.
Régler le modèle et les hyperparamètres- Ajuster les hyperparamètres du modèle en fonction des résultats de l'évaluation afin d'optimiser davantage les performances du modèle.

Un exemple simple d'apprentissage automatique : classification avec Scikit-learn

Scikit-learn (abrégé en Sklearn) est une bibliothèque d'apprentissage automatique open source, construite sur des bibliothèques de calcul scientifique telles que NumPy, SciPy et matplotlib, offrant des outils simples et efficaces de fouille de données et d'analyse de données.

Scikit-learn inclut de nombreux algorithmes d'apprentissage automatique courants, notamment :

Régression linéaire, régression ridge, régression Lasso
Machines à vecteurs de support (SVM)
Arbres de décision, forêts aléatoires, arbres de gradient boosting
Algorithmes de clustering (par exemple, K-Means, clustering hiérarchique, DBSCAN)
Techniques de réduction de dimensionnalité (par exemple, PCA, t-SNE)
Réseaux de neurones

Ensuite, nous allons démontrer le processus d'apprentissage automatique à l'aide d'une tâche de classification simple — le jeu de données Iris. Le jeu de données Iris est un jeu de données classique contenant 150 échantillons, décrivant les longueurs et largeurs des pétales et des sépales de trois types différents de fleurs d'iris.

Étape 1 : Importer les bibliothèques

Importez les bibliothèques Python requises :

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

Étape 2 : Charger les données

Chargez le jeu de données Iris :

Exemple

# Charger le jeu de données Iris
iris = load_iris()

# Convertir les données en un DataFrame pandas
X = pd.DataFrame(iris.data, columns=iris.feature_names) # Données de caractéristiques
y = pd.Series(iris.target) # Données d'étiquettes

# Afficher les cinq premières lignes de données
print(X.head())

Les données de sortie imprimées sont les suivantes :

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)
0                5.1               3.5                1.4               0.2
1                4.9               3.0                1.4               0.2
2                4.7               3.2                1.3               0.2
3                4.6               3.1                1.5               0.2
4                5.0               3.6                1.4               0.2

Étape 3 : Diviser le jeu de données

Diviser le jeu de données en ensembles d'entraînement et de test, en utilisant généralement un ratio de 70% pour l'ensemble d'entraînement et de 30% pour l'ensemble de test :

Exemple

# Diviser les ensembles d'entraînement et de test (80% entraînement, 20% test)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Étape 4 : Mise à l'échelle des caractéristiques (standardisation)

De nombreux algorithmes d'apprentissage automatique dépendent de l'échelle des caractéristiques, en particulier des algorithmes comme K-Nearest Neighbors. Pour garantir que chaque caractéristique a une moyenne de 0 et un écart-type de 1, nous utilisons la standardisation pour traiter les données :

Exemple

# Standardiser les caractéristiques
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Étape 5 : Choisir un modèle et l'entraîner

Dans cet exemple, nous choisissons l'algorithme K-Nearest Neighbors (KNN) pour la classification :

Exemple

# Créer un classificateur KNN
knn = KNeighborsClassifier(n_neighbors=3)

# Entraîner le modèle
knn.fit(X_train, y_train)

Étape 6 : Évaluer le modèle

Après l'entraînement, nous utilisons l'ensemble de test pour évaluer la précision du modèle :

Exemple

# Prédire l'ensemble de test
y_pred = knn.predict(X_test)

# Calculer la précision
accuracy = accuracy_score(y_test, y_pred)
print(f'Précision du modèle : {accuracy:.2f}')

Après avoir exécuté le code ci-dessus, la sortie est :

模型准确率: 1.00

Étape 7 : Visualiser les résultats (facultatif)

Vous pouvez mieux comprendre les performances du modèle grâce à la visualisation, en particulier avec des jeux de données multidimensionnels. Par exemple, vous pouvez utiliser un graphique 2D pour afficher les résultats de classification KNN (bien que vous deviez réduire la dimensionnalité des données à deux dimensions).

Exemple

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Charger le jeu de données Iris
iris = load_iris()

# Convertir les données en pandas DataFrame
X = pd.DataFrame(iris.data, columns=iris.feature_names) # Données de caractéristiques
y = pd.Series(iris.target) # Données d'étiquettes

# Diviser les ensembles d'entraînement et de test (80% entraînement, 20% 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
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Créer un classificateur KNN
knn = KNeighborsClassifier(n_neighbors=3)

# Entraîner le modèle
knn.fit(X_train, y_train)

# Prédire l'ensemble de test
y_pred = knn.predict(X_test)

# Calculer la précision
accuracy = accuracy_score(y_test, y_pred)

# Visualisation - ce n'est qu'un exemple simple ; vous pouvez choisir la méthode de tracé en fonction de la situation réelle
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred, cmap='viridis', marker='o')
plt.title("Résultats de classification KNN")
plt.xlabel("Caractéristique 1")
plt.ylabel("Caractéristique 2")
plt.show()

L'image de sortie est affichée ci-dessous :

Autres extensions

Traitement des données et statistiques

Apprentissage supervisé

Apprentissage non supervisé

Apprentissage par renforcement

Apprentissage profond

Optimisation et ingénierie des modèles

Limites et frontières de l'apprentissage automatique

Cas pratiques

Premiers pas avec l'apprentissage automatique en Python

Installation de Python et des bibliothèques nécessaires

Méthode 1 : installateur officiel

Méthode 2 : distribution Anaconda

Avantages d'Anaconda

Installer Anaconda

Pourquoi avez-vous besoin d'environnements virtuels ?

Avantages des environnements virtuels

Gestion des environnements avec conda

Configuration des outils de développement

Jupyter Notebook

Installation et démarrage de Jupyter

Utilisation de base de Jupyter

Exemple

Configuration de VS Code

Plugins recommandés

Exemple de configuration VS Code

Installation des bibliothèques d'apprentissage automatique

Un exemple simple d'apprentissage automatique : classification avec Scikit-learn

Étape 1 : Importer les bibliothèques

Étape 2 : Charger les données

Exemple

Étape 3 : Diviser le jeu de données

Exemple

Étape 4 : Mise à l'échelle des caractéristiques (standardisation)

Exemple

Étape 5 : Choisir un modèle et l'entraîner

Exemple

Étape 6 : Évaluer le modèle

Exemple

Étape 7 : Visualiser les résultats (facultatif)

Exemple