Machine Learning avec Python : Théorie, Pratique et Applications avec Anaconda

Plan du Livre :

Partie 1 : Introduction au Machine Learning

1. Chapitre 1 : Qu'est-ce que le Machine Learning ?

o Définition et concepts de base
o Différence entre apprentissage supervisé, non supervisé et par
renforcement
o Applications du machine learning dans le monde réel
2. Chapitre 2 : Environnement de Travail avec Python et Anaconda
o Installation d'Anaconda et configuration de l'environnement
o Présentation des bibliothèques essentielles : NumPy, Pandas, Matplotlib,
Scikit-Learn, TensorFlow, Keras
o Bonnes pratiques pour organiser un projet de machine learning

Partie 2 : Fondements Mathématiques et Statistiques

3. Chapitre 3 : Bases Mathématiques pour le Machine Learning

o Algèbre linéaire : vecteurs, matrices, produits matriciels
o Calcul différentiel : gradients, dérivées partielles
o Probabilités et statistiques : distributions, espérance, variance, Bayes
4. Chapitre 4 : Prétraitement des Données
o Nettoyage des données : gestion des valeurs manquantes, des doublons
o Normalisation et standardisation
o Réduction de dimension : PCA, t-SNE

Partie 3 : Apprentissage Supervisé

5. Chapitre 5 : Régression Linéaire et Polynomiale

o Théorie : hypothèses, fonction de coût, descente de gradient
o Pratique : implémentation avec Scikit-Learn
6. Chapitre 6 : Classification
o Régression logistique
o Arbres de décision et forêts aléatoires
o SVM (Machines à vecteurs de support)
7. Chapitre 7 : Évaluation des Modèles
o Métriques de performance : précision, rappel, F1-score, ROC-AUC
o Validation croisée et surapprentissage

ALPHONSE KAZADI | +243 858458037 | [email protected] 1

Partie 4 : Apprentissage Non Supervisé

8. Chapitre 8 : Clustering
o K-means
o DBSCAN
o Clustering hiérarchique
9. Chapitre 9 : Réduction de Dimension
o Analyse en composantes principales (PCA)
o Factorisation matricielle

Partie 5 : Deep Learning

10. Chapitre 10 : Introduction aux Réseaux de Neurones

o Perceptron multicouche (MLP)
o Fonctions d'activation : ReLU, sigmoïde, softmax
o Rétropropagation et optimisation
11. Chapitre 11 : Réseaux de Neurones Convolutifs (CNN)
o Applications en vision par ordinateur
o Implémentation avec Keras/TensorFlow
12. Chapitre 12 : Réseaux de Neurones Récurrents (RNN)
o Applications en traitement du langage naturel (NLP)
o LSTM et GRU

Partie 6 : Projets Pratiques

13. Chapitre 13 : Projet 1 - Prédiction de Prix Immobiliers

o Régression linéaire et évaluation du modèle
14. Chapitre 14 : Projet 2 - Classification d'Images avec CNN
o Utilisation de Keras pour entraîner un modèle sur MNIST ou CIFAR-10
15. Chapitre 15 : Projet 3 - Analyse de Sentiments avec NLP
o Prétraitement de texte et utilisation de RNN

Partie 7 : Annexes

 Installation et configuration avancée d'Anaconda

 Ressources supplémentaires : cours en ligne, datasets, compétitions Kaggle
 Glossaire des termes techniques

ALPHONSE KAZADI | +243 858458037 | [email protected] 2

Partie 1 : Introduction au Machine Learning

Chapitre 1 : Qu'est-ce que le Machine Learning ?

1.1 Définition et Concepts de Base

 Le machine learning (apprentissage automatique) est une branche de

l'intelligence artificielle qui permet aux systèmes d'apprendre à partir de
données sans être explicitement programmés.
 Apprentissage supervisé : Le modèle apprend à partir de données étiquetées
(exemple : prédiction de prix).
 Apprentissage non supervisé : Le modèle découvre des patterns dans des
données non étiquetées (exemple : clustering).
 Apprentissage par renforcement : Le modèle apprend en interagissant avec
un environnement et en recevant des récompenses ou des pénalités (exemple :
jeux vidéo).

1.2 Applications du Machine Learning

 Vision par ordinateur : Reconnaissance d'images, détection d'objets.

 Traitement du langage naturel (NLP) : Traduction automatique, analyse de
sentiments.
 Systèmes de recommandation : Netflix, Amazon.
 Santé : Diagnostic médical, analyse d'images radiologiques.

1.3 Pourquoi Python pour le Machine Learning ?

 Python est simple, flexible et dispose d'une vaste communauté.

 Bibliothèques populaires : NumPy, Pandas, Scikit-Learn, TensorFlow, Keras.
 Anaconda simplifie la gestion des environnements et des dépendances.

Chapitre 2 : Environnement de Travail avec Python et Anaconda

2.1 Installation d'Anaconda

 Téléchargement et installation d'Anaconda depuis anaconda.com.

 Création d'un environnement virtuel pour isoler les dépendances du projet.

2.2 Présentation des Bibliothèques Essentielles

 NumPy : Manipulation de tableaux multidimensionnels et calculs numériques.

 Pandas : Manipulation et analyse de données tabulaires.
 Matplotlib et Seaborn : Visualisation de données.
 Scikit-Learn : Algorithmes de machine learning prêts à l'emploi.
 TensorFlow et Keras : Deep learning et réseaux de neurones.
ALPHONSE KAZADI | +243 858458037 | [email protected] 3
2.3 Configuration de l'Environnement

 Utilisation de Jupyter Notebook pour un développement interactif.

 Installation des bibliothèques via conda ou pip :
conda install numpy pandas matplotlib scikit-learn
pip install tensorflow keras

2.4 Bonnes Pratiques pour Organiser un Projet

 Structure de dossier recommandée :

mon_projet_ml/
├── data/ # Dossier pour les datasets
├── notebooks/ # Jupyter Notebooks
├── scripts/ # Scripts Python
├── models/ # Modèles sauvegardés
└── README.md # Documentation du projet
 Utilisation de Git pour le versionnement du code.

2.5 Premier Programme en Python

 Exemple simple pour vérifier l'installation des bibliothèques :

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Création d'un tableau NumPy

data = np.array([1, 2, 3, 4, 5])
print("Tableau NumPy :", data)

# Création d'un DataFrame Pandas

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
print("DataFrame Pandas :\n", df)

# Visualisation avec Matplotlib

plt.plot([1, 2, 3], [4, 5, 6])
plt.title("Exemple de Graphique")
plt.show()

ALPHONSE KAZADI | +243 858458037 | [email protected] 4

Exercices Pratiques pour la Partie 1

Exercice 1 : Installation et Configuration

1. Installez Anaconda sur votre machine.

2. Créez un environnement virtuel nommé ml_env et installez les bibliothèques
suivantes : NumPy, Pandas, Matplotlib, Scikit-Learn.

Exercice 2 : Exploration de Données

1. Téléchargez le dataset Iris depuis Scikit-Learn :

from sklearn.datasets import load_iris
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = iris.target
2. Affichez les 5 premières lignes du dataset.
3. Utilisez Matplotlib pour visualiser la distribution des caractéristiques (features).

Exercice 3 : Premier Modèle de Machine Learning

1. Utilisez Scikit-Learn pour entraîner un modèle de régression linéaire sur un

dataset simple :
from sklearn.linear_model import LinearRegression
X = [[1], [2], [3], [4], [5]]
y = [2, 4, 6, 8, 10]
model = LinearRegression()
model.fit(X, y)
print("Prédiction pour X=6 :", model.predict([[6]]))

ALPHONSE KAZADI | +243 858458037 | [email protected] 5

Partie 2 : Fondements Mathématiques et Statistiques

Chapitre 3 : Bases Mathématiques pour le Machine Learning

3.1 Algèbre Linéaire

 Vecteurs et Matrices :
o Un vecteur est une liste de nombres, souvent représenté comme une
colonne ou une ligne.
o Une matrice est un tableau de nombres disposés en lignes et colonnes.
o Exemple en Python avec NumPy :
import numpy as np
vecteur = np.array([1, 2, 3])
matrice = np.array([[1, 2], [3, 4]])
print("Vecteur :", vecteur)
print("Matrice :\n", matrice)
 Produit Matriciel :
o Le produit matriciel est une opération clé en machine learning,
notamment pour les réseaux de neurones.
o Exemple :
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
produit = np.dot(A, B)
print("Produit Matriciel :\n", produit)

3.2 Calcul Différentiel

 Dérivées et Gradients :
o Les dérivées mesurent comment une fonction change lorsque ses entrées
changent.
o Le gradient est un vecteur de dérivées partielles, utilisé pour optimiser
les modèles.
o Exemple de calcul de dérivée avec SymPy :
import sympy as sp
x = sp.symbols('x')
f = x**2 + 3*x + 2
derivee = sp.diff(f, x)
print("Dérivée de f(x) :", derivee)

ALPHONSE KAZADI | +243 858458037 | [email protected] 6

3.3 Probabilités et Statistiques

 Distributions de Probabilité :
o La distribution normale (gaussienne) est souvent utilisée en machine
learning.
o Exemple de génération de données avec NumPy :
donnees = np.random.normal(0, 1, 1000) # Moyenne 0, écart-type 1

 Théorème de Bayes :
o Utilisé dans les algorithmes de classification naïve bayésienne.
o Formule : P(A∣B)=P(B∣A)⋅P(A)P(B)P(A∣B)=P(B)P(B∣A)⋅P(A)

Chapitre 4 : Prétraitement des Données

4.1 Nettoyage des Données

 Gestion des Valeurs Manquantes :

o Suppression ou imputation des valeurs manquantes.
o Exemple avec Pandas :
import pandas as pd
df = pd.DataFrame({'A': [1, 2, np.nan], 'B': [4, np.nan, 6]})
df_rempli = df.fillna(df.mean()) # Remplacer par la moyenne
print(df_rempli)
 Gestion des Doublons :
o Suppression des lignes en double.
o Exemple :
df = pd.DataFrame({'A': [1, 2, 2], 'B': [4, 5, 5]})
df_sans_doublons = df.drop_duplicates()
print(df_sans_doublons)

4.2 Normalisation et Standardisation

 Normalisation : Mise à l'échelle des données entre 0 et 1.

o Exemple avec Scikit-Learn :
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
donnees_normalisees = scaler.fit_transform([[1, 2], [3, 4]])
print(donnees_normalisees)
 Standardisation : Mise à l'échelle des données pour avoir une moyenne de 0 et
un écart-type de 1.
o Exemple :
from sklearn.preprocessing import StandardScaler

ALPHONSE KAZADI | +243 858458037 | [email protected] 7

 scaler = StandardScaler()
donnees_standardisees = scaler.fit_transform([[1, 2], [3, 4]])
print(donnees_standardisees)

4.3 Réduction de Dimension

 Analyse en Composantes Principales (PCA) :

o Réduit le nombre de variables tout en conservant l'information
importante.
o Exemple avec Scikit-Learn :
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
donnees_reduites = pca.fit_transform([[1, 2, 3], [4, 5, 6]])
print(donnees_reduites)
 t-SNE :
o Utilisé pour visualiser des données en 2D ou 3D.
o Exemple :
from sklearn.manifold import TSNE
tsne = TSNE(n_components=2)
donnees_tsne = tsne.fit_transform([[1, 2, 3], [4, 5, 6]])
print(donnees_tsne)

Exercices Pratiques pour la Partie 2

Exercice 1 : Manipulation de Matrices

1. Créez deux matrices AA et BB de taille 2×22×2 avec NumPy.

2. Calculez leur produit matriciel et affichez le résultat.

Exercice 2 : Nettoyage de Données

1. Créez un DataFrame Pandas avec des valeurs manquantes.

2. Imputez les valeurs manquantes avec la médiane.

Exercice 3 : Réduction de Dimension

1. Appliquez PCA sur le dataset Iris pour réduire les dimensions à 2.

2. Visualisez les données réduites avec Matplotlib.

ALPHONSE KAZADI | +243 858458037 | [email protected] 8

Partie 3 : Apprentissage Supervisé

Chapitre 5 : Régression Linéaire et Polynomiale

5.1 Introduction à la Régression

 La régression est utilisée pour prédire une valeur continue (exemple : prix d'une
maison).
 Régression linéaire : Modélise une relation linéaire entre les variables
indépendantes et la variable cible.
 Régression polynomiale : Étend la régression linéaire pour modéliser des
relations non linéaires.

5.2 Théorie de la Régression Linéaire

 Hypothèse : y=β0+β1X1+β2X2+⋯+βnXn+ϵy=β0+β1X1+β2X2+⋯+βnXn+ϵ
 Fonction de coût : Erreur quadratique moyenne (MSE).
 Descente de gradient : Algorithme pour minimiser la fonction de coût.

5.3 Implémentation avec Scikit-Learn

 Exemple de régression linéaire :

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import numpy as np

# Génération de données
np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

# Séparation des données

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state
=42)

# Entraînement du modèle
model = LinearRegression()
model.fit(X_train, y_train)

# Prédiction et évaluation
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print(f"Erreur Quadratique Moyenne (MSE) : {mse:.2f}")

ALPHONSE KAZADI | +243 858458037 | [email protected] 9

5.4 Régression Polynomiale

 Transformation des features pour inclure des termes polynomiaux.

 Exemple :
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(degree=2)
X_poly = poly.fit_transform(X)
model.fit(X_poly, y)

Chapitre 6 : Classification

6.1 Introduction à la Classification

 La classification est utilisée pour prédire une classe discrète (exemple : spam ou
non spam).
 Algorithmes populaires : Régression logistique, arbres de décision, SVM.

6.2 Régression Logistique

 Utilisée pour les problèmes de classification binaire.

 Fonction sigmoïde : σ(z)=11+e−zσ(z)=1+e−z1
 Exemple avec Scikit-Learn :
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Chargement des données

iris = load_iris()
X = iris.data[:, :2] # Utilisation des deux premières features
y = (iris.target == 0).astype(int) # Classification binaire (setosa ou non)

# Séparation des données

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state
=42)

# Entraînement du modèle
model = LogisticRegression()
model.fit(X_train, y_train)

# Prédiction et évaluation
y_pred = model.predict(X_test)
ALPHONSE KAZADI | +243 858458037 | [email protected] 10
 accuracy = accuracy_score(y_test, y_pred)
print(f"Précision : {accuracy:.2f}")

6.3 Arbres de Décision et Forêts Aléatoires

 Arbres de décision : Divisent les données en fonction des features.

 Forêts aléatoires : Combinaison de plusieurs arbres pour améliorer la
performance.
 Exemple :
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Précision : {accuracy:.2f}")

6.4 Machines à Vecteurs de Support (SVM)

 Trouve l'hyperplan optimal pour séparer les classes.

 Exemple :
from sklearn.svm import SVC
model = SVC(kernel='linear')
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Précision : {accuracy:.2f}")

Chapitre 7 : Évaluation des Modèles

7.1 Métriques de Performance

 Précision : Proportion de prédictions correctes.

 Rappel : Proportion de vrais positifs détectés.
 F1-score : Moyenne harmonique de la précision et du rappel.
 ROC-AUC : Aire sous la courbe ROC pour les problèmes de classification.

7.2 Validation Croisée

 Technique pour évaluer la performance du modèle sur plusieurs sous-

ensembles de données.
 Exemple :
from sklearn.model_selection import cross_val_score
scores = cross_val_score(model, X, y, cv=5)
print(f"Scores de validation croisée : {scores}")
ALPHONSE KAZADI | +243 858458037 | [email protected] 11
 print(f"Moyenne des scores : {scores.mean():.2f}")

7.3 Surapprentissage et Sous-apprentissage

 Surapprentissage : Le modèle performe bien sur les données d'entraînement

mais mal sur les données de test.
 Sous-apprentissage : Le modèle ne capture pas bien les patterns des données.
 Solutions : Régularisation, augmentation des données, simplification du modèle.

Exercices Pratiques pour la Partie 3

Exercice 1 : Régression Linéaire

1. Utilisez le dataset Boston Housing pour entraîner un modèle de régression

linéaire.
2. Évaluez le modèle avec l'erreur quadratique moyenne (MSE).

Exercice 2 : Classification avec SVM

1. Utilisez le dataset Iris pour entraîner un modèle SVM avec un noyau RBF.
2. Évaluez le modèle avec la précision et la matrice de confusion.

Exercice 3 : Validation Croisée

1. Appliquez une validation croisée à un modèle de forêt aléatoire sur le dataset

Wine.
2. Comparez les scores de validation croisée avec la précision sur l'ensemble de
test.

ALPHONSE KAZADI | +243 858458037 | [email protected] 12

Partie 4 : Apprentissage Non Supervisé

Chapitre 8 : Clustering

8.1 Introduction au Clustering

 Le clustering regroupe des données similaires en clusters (groupes).

 Applications : Segmentation de marché, regroupement de documents, analyse
de réseaux sociaux.

8.2 K-means

 Algorithme populaire pour diviser les données en kk clusters.

 Étapes :
1. Choisir kk centroïdes initiaux.
2. Assigner chaque point au centroïde le plus proche.
3. Mettre à jour les centroïdes.
4. Répéter jusqu'à convergence.
 Exemple avec Scikit-Learn :
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

# Génération de données
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=
0)

# Application de K-means
kmeans = KMeans(n_clusters=4)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)

# Visualisation des clusters

plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.75)
plt.title("Clustering avec K-means")
plt.show()

ALPHONSE KAZADI | +243 858458037 | [email protected] 13

8.3 DBSCAN

 Algorithme basé sur la densité, capable de détecter des clusters de formes

arbitraires.
 Paramètres : eps (distance maximale entre deux points)
et min_samples (nombre minimal de points pour former un cluster).
 Exemple :
from sklearn.cluster import DBSCAN
dbscan = DBSCAN(eps=0.3, min_samples=10)
y_dbscan = dbscan.fit_predict(X)

# Visualisation des clusters

plt.scatter(X[:, 0], X[:, 1], c=y_dbscan, s=50, cmap='viridis')
plt.title("Clustering avec DBSCAN")
plt.show()

8.4 Clustering Hiérarchique

 Crée une hiérarchie de clusters, représentée par un dendrogramme.

 Exemple :
from scipy.cluster.hierarchy import dendrogram, linkage
Z = linkage(X, method='ward')
dendrogram(Z)
plt.title("Dendrogramme")
plt.show()

ALPHONSE KAZADI | +243 858458037 | [email protected] 14

Chapitre 9 : Réduction de Dimension

9.1 Introduction à la Réduction de Dimension

 Réduit le nombre de variables tout en conservant l'information importante.

 Utile pour la visualisation, la compression de données et l'amélioration des
performances des modèles.

9.2 Analyse en Composantes Principales (PCA)

 Transforme les données en un nouvel ensemble de variables non corrélées

(composantes principales).
 Exemple avec Scikit-Learn :
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# Visualisation des données réduites

plt.scatter(X_pca[:, 0], X_pca[:, 1], cmap='viridis')
plt.title("PCA : Réduction à 2 Dimensions")
plt.show()

9.3 t-SNE (t-Distributed Stochastic Neighbor Embedding)

 Technique de réduction de dimension pour la visualisation de données en 2D

ou 3D.
 Exemple :
from sklearn.manifold import TSNE
tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X)

# Visualisation des données réduites

plt.scatter(X_tsne[:, 0], X_tsne[:, 1], cmap='viridis')
plt.title("t-SNE : Réduction à 2 Dimensions")
plt.show()

9.4 Factorisation Matricielle

 Utilisée pour décomposer une matrice en produits de matrices de rang inférieur.

 Applications : Recommandation de produits, analyse de textes.

ALPHONSE KAZADI | +243 858458037 | [email protected] 15

Exercices Pratiques pour la Partie 4

Exercice 1 : Clustering avec K-means

1. Utilisez le dataset Iris pour appliquer K-means avec k=3k=3.

2. Visualisez les clusters avec Matplotlib.

Exercice 2 : Réduction de Dimension avec PCA

1. Appliquez PCA sur le dataset Wine pour réduire les dimensions à 2.

2. Visualisez les données réduites.

Exercice 3 : Clustering Hiérarchique

1. Utilisez le dataset Iris pour créer un dendrogramme.

2. Identifiez les clusters naturels dans les données.

ALPHONSE KAZADI | +243 858458037 | [email protected] 16

Partie 5 : Deep Learning

Chapitre 10 : Introduction aux Réseaux de Neurones

10.1 Qu'est-ce que le Deep Learning ?

 Le deep learning est une sous-catégorie du machine learning qui utilise des
réseaux de neurones artificiels pour modéliser des patterns complexes dans les
données.
 Applications : Vision par ordinateur, traitement du langage naturel,
reconnaissance vocale.

10.2 Structure d'un Neurone Artificiel

 Entrées : Les données d'entrée (x1,x2,…,xnx1,x2,…,xn).

 Poids : Chaque entrée est multipliée par un poids (w1,w2,…,wnw1,w2,…,wn).
 Biais : Un terme additionnel (bb).
 Fonction d'Activation : Introduit de la non-linéarité (exemple : ReLU,
sigmoïde).

10.3 Fonctions d'Activation

 ReLU (Rectified Linear Unit) : f(x)=max⁡(0,x)f(x)=max(0,x)

 Sigmoïde : f(x)=11+e−xf(x)=1+e−x1
 Softmax : Utilisée pour les problèmes de classification multi-classes.

10.4 Architecture d'un Réseau de Neurones

 Couche d'Entrée : Reçoit les données d'entrée.

 Couches Cachées : Transformations intermédiaires.
 Couche de Sortie : Produit la prédiction finale.

10.5 Rétropropagation et Descente de Gradient

 Rétropropagation : Algorithme pour ajuster les poids en fonction de l'erreur.

 Descente de Gradient : Minimise la fonction de coût en ajustant les poids.

ALPHONSE KAZADI | +243 858458037 | [email protected] 17

Chapitre 11 : Réseaux de Neurones Convolutifs (CNN)

11.1 Introduction aux CNN

 Les CNN sont spécialisés pour le traitement de données structurées en grille,

comme les images.
 Applications : Reconnaissance d'images, détection d'objets.

11.2 Architecture d'un CNN

 Couche Convolutive : Applique des filtres pour extraire des features.

 Couche de Pooling : Réduit la dimension spatiale.
 Couche Fully Connected : Produit la prédiction finale.

11.3 Implémentation avec Keras/TensorFlow

 Exemple de CNN pour la classification d'images (MNIST) :

from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# Chargement des données

(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape((X_train.shape[0], 28, 28, 1)).astype('float32') / 255
X_test = X_test.reshape((X_test.shape[0], 28, 28, 1)).astype('float32') / 255
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

# Construction du modèle
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

# Compilation du modèle
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['ac
curacy'])

# Entraînement du modèle
model.fit(X_train, y_train, epochs=5, batch_size=64, validation_split=0.2)
ALPHONSE KAZADI | +243 858458037 | [email protected] 18
 # Évaluation du modèle
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"Précision sur l'ensemble de test : {test_acc:.2f}")

Chapitre 12 : Réseaux de Neurones Récurrents (RNN)

12.1 Introduction aux RNN

 Les RNN sont conçus pour traiter des données séquentielles, comme les séries
temporelles ou le texte.
 Applications : Traduction automatique, génération de texte.

12.2 Architecture d'un RNN

 Cellule Récurrente : Maintient une mémoire des états précédents.

 Problème de Vanishing Gradient : Les gradients peuvent devenir très petits,
rendant l'apprentissage difficile.
 LSTM (Long Short-Term Memory) : Variante des RNN pour résoudre le
problème de vanishing gradient.

12.3 Implémentation avec Keras/TensorFlow

 Exemple de LSTM pour la prédiction de séries temporelles :

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
import numpy as np

# Génération de données
def generate_sequence(length):
return np.array([i/float(length) for i in range(length)])

def generate_dataset(n_samples, length):

X, y = [], []
for _ in range(n_samples):
seq = generate_sequence(length)
X.append(seq[:-1])
y.append(seq[-1])
return np.array(X), np.array(y)

X, y = generate_dataset(1000, 10)
X = X.reshape((X.shape[0], X.shape[1], 1))

ALPHONSE KAZADI | +243 858458037 | [email protected] 19

 # Construction du modèle
model = Sequential()
model.add(LSTM(50, input_shape=(9, 1)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

# Entraînement du modèle
model.fit(X, y, epochs=200, batch_size=32)

# Prédiction
test_input = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
test_input = test_input.reshape((1, 9, 1))
prediction = model.predict(test_input)
print(f"Prédiction : {prediction[0][0]:.2f}")

Exercices Pratiques pour la Partie 5

Exercice 1 : CNN pour la Classification d'Images

1. Utilisez le dataset CIFAR-10 pour entraîner un CNN.

2. Évaluez la performance du modèle sur l'ensemble de test.

Exercice 2 : RNN pour la Génération de Texte

1. Utilisez un dataset de texte (comme Shakespeare) pour entraîner un LSTM.

2. Générez du texte à partir du modèle entraîné.

Exercice 3 : Transfer Learning

1. Utilisez un modèle pré-entraîné (comme VGG16) pour la classification d'images.

2. Fine-tune le modèle sur un dataset personnalisé.

ALPHONSE KAZADI | +243 858458037 | [email protected] 20

Partie 6 : Projets Pratiques

Projet 1 : Prédiction de Prix Immobiliers

Objectif : Construire un modèle de régression pour prédire le prix des maisons en

fonction de leurs caractéristiques.

Étapes :

1. Chargement des Données :

o Utilisez le dataset Boston Housing ou un autre dataset de prix
immobiliers.

from sklearn.datasets import load_boston

import pandas as pd

boston = load_boston()
df = pd.DataFrame(boston.data, columns=boston.feature_names)
df['PRICE'] = boston.target
2. Exploration des Données :
o Analysez les données avec des statistiques descriptives et des
visualisations.

import seaborn as sns

import matplotlib.pyplot as plt

sns.pairplot(df)
plt.show()
3. Prétraitement des Données :
o Normalisez les features et divisez les données en ensembles
d'entraînement et de test.

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

X = df.drop('PRICE', axis=1)
y = df['PRICE']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state
=42)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

ALPHONSE KAZADI | +243 858458037 | [email protected] 21

 4. Entraînement du Modèle :
o Utilisez la régression linéaire ou un autre algorithme de régression.

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error

model = LinearRegression()
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print(f"Erreur Quadratique Moyenne (MSE) : {mse:.2f}")
5. Évaluation du Modèle :
o Visualisez les prédictions par rapport aux valeurs réelles.

plt.scatter(y_test, y_pred)
plt.xlabel("Prix Réel")
plt.ylabel("Prix Prédit")
plt.title("Prix Réel vs Prix Prédit")
plt.show()

Projet 2 : Classification d'Images avec CNN

Objectif : Construire un modèle de classification d'images en utilisant un réseau de

neurones convolutif (CNN).

Étapes :

1. Chargement des Données :

o Utilisez le dataset CIFAR-10.

from tensorflow.keras.datasets import cifar10

(X_train, y_train), (X_test, y_test) = cifar10.load_data()
2. Prétraitement des Données :
o Normalisez les images et convertissez les labels en catégories.

X_train = X_train.astype('float32') / 255

X_test = X_test.astype('float32') / 255

from tensorflow.keras.utils import to_categorical

y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

ALPHONSE KAZADI | +243 858458037 | [email protected] 22

 3. Construction du Modèle :
o Créez un CNN avec Keras.

from tensorflow.keras import layers, models

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
4. Compilation et Entraînement :
o Compilez et entraînez le modèle.

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['ac

curacy'])
model.fit(X_train, y_train, epochs=10, batch_size=64, validation_split=0.2)
5. Évaluation du Modèle :
o Évaluez la performance sur l'ensemble de test.

test_loss, test_acc = model.evaluate(X_test, y_test)

print(f"Précision sur l'ensemble de test : {test_acc:.2f}")

Projet 3 : Analyse de Sentiments avec NLP

Objectif : Construire un modèle pour analyser les sentiments à partir de textes.

Étapes :

1. Chargement des Données :

o Utilisez un dataset d'analyse de sentiments (exemple : IMDb).

from tensorflow.keras.datasets import imdb

(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=10000)
2. Prétraitement des Données :
o Vectorisez les textes et paddez les séquences.

from tensorflow.keras.preprocessing.sequence import pad_sequences

X_train = pad_sequences(X_train, maxlen=500)

ALPHONSE KAZADI | +243 858458037 | [email protected] 23

 X_test = pad_sequences(X_test, maxlen=500)
3. Construction du Modèle :
o Créez un modèle LSTM avec Keras.

from tensorflow.keras import layers, models

model = models.Sequential()
model.add(layers.Embedding(10000, 128))
model.add(layers.LSTM(64))
model.add(layers.Dense(1, activation='sigmoid'))
4. Compilation et Entraînement :
o Compilez et entraînez le modèle.

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accura

cy'])
model.fit(X_train, y_train, epochs=5, batch_size=64, validation_split=0.2)
5. Évaluation du Modèle :
o Évaluez la performance sur l'ensemble de test.

test_loss, test_acc = model.evaluate(X_test, y_test)

print(f"Précision sur l'ensemble de test : {test_acc:.2f}")

ALPHONSE KAZADI | +243 858458037 | [email protected] 24