DATA SCIENCE

&
DEEP LEARNING
Cours complet — Niveau Intermédiaire à Pro

Professeur Expert — 15 ans d'expérience industrie

Couverture : Data Science • Machine Learning • Deep Learning • Vision
par ordinateur
PARTIE 1 — DATA SCIENCE

1.1 Définition
La Data Science est un domaine interdisciplinaire qui combine statistiques, programmation et
expertise métier pour extraire de la connaissance et de la valeur à partir de données brutes.
Son objectif : transformer des données en décisions.

🎯 Analogie simple

La Data Science, c'est comme être détective : tu collectes des indices (données), tu les
analyses (modèles), tu formules une hypothèse (insight) et tu la testes (validation). Chaque
projet est une enquête différente.

1.2 Cycle de vie d'un projet Data Science

Étape Nom Description & livrables clés

01 Définition du problème Comprendre le besoin métier. Poser les bonnes questions.

Définir KPIs & critères de succès.

02 Collecte des données APIs, bases de données, scraping, CSV. Identifier les
sources, volumes, formats disponibles.

03 Exploration (EDA) Statistiques descriptives, visualisations, corrélations.

Comprendre la distribution et la qualité des données.

04 Nettoyage & Traitement des valeurs manquantes, outliers, doublons,

Préparation encodage, normalisation. Souvent 60-70% du temps
projet.

05 Modélisation Sélection d'algorithmes, entraînement, tuning

d'hyperparamètres, cross-validation.

06 Évaluation Métriques (accuracy, F1, AUC-ROC, RMSE…), tests sur

données holdout, analyse d'erreurs.

07 Déploiement API REST (FastAPI/Flask), conteneurisation Docker,

intégration CI/CD, monitoring en production.

08 Monitoring & Data drift, model drift, retrain automatique, dashboards de

 Maintenance surveillance, feedback loop.

1.3 Les métiers de la Data

Data Analyst Data Scientist ML Engineer Data Engineer

Comprend & visualise Construit des modèles Déploie & industrialise Construit les pipelines
les données passées prédictifs les modèles de données

SQL, Excel, Tableau, Python, scikit-learn, PyTorch, TF, Docker, Spark, Airflow, Kafka,
Power BI stats, ML Kubernetes SQL

1.4 Outils clés de l'écosystème

Catégorie Outils phares

Langage Python (dominant), R (stats), SQL (données)

EDA & Viz Pandas, Matplotlib, Seaborn, Plotly, Tableau

ML classique Scikit-learn, XGBoost, LightGBM, CatBoost

Deep Learning PyTorch (recherche & prod), TensorFlow/Keras, JAX

MLOps MLflow, Weights & Biases, Docker, FastAPI, Airflow

Cloud AWS SageMaker, GCP Vertex AI, Azure ML, Hugging Face
PARTIE 2 — DEEP LEARNING

2.1 Définition
Le Deep Learning est un sous-ensemble du Machine Learning qui utilise des réseaux de
neurones artificiels profonds (multi-couches) pour apprendre des représentations
hiérarchiques à partir de données. Inspiré du cerveau, il excelle sur les données non-
structurées : images, texte, audio.

2.2 Machine Learning Classique vs Deep Learning

Critère ML Classique Deep Learning

Feature Engineering Manuel — l'expert crée les Automatique — le réseau

features l'apprend

Volume de données Fonctionne avec peu de données Nécessite beaucoup de données

(millions)

Calcul GPU CPU suffit souvent GPU quasi obligatoire

Interprétabilité Bonne (arbres, régression) Faible (boîte noire)

Performance images/texte Limitée State-of-the-art

Exemples d'algos Random Forest, SVM, XGBoost CNN, RNN, Transformer, MLP

🎯 Analogie

ML classique = cuisiner avec une recette précise. Deep Learning = laisser un chef goûter
des milliers de plats et inventer lui-même la recette.
PARTIE 3 — RÉSEAUX DE NEURONES ARTIFICIELS

3.1 Le Neurone Artificiel — Schéma & Formule

Schéma d'un neurone artificiel :

x₁ ──── w₁ ──────┐
│
x₂ ──── w₂ ───── [ Σ(wᵢxᵢ) + b ] ──── f(z) ────▶ ŷ (sortie)
│ agrégation activation
x₃ ──── w₃ ──────┘
+ biais b (toujours présent)

📐 Formule mathématique complète

z = w₁x₁ + w₂x₂ + w₃x₃ + ... + wₙxₙ + b = Σ(wᵢxᵢ) + b

ŷ = f(z) où f est la fonction d'activation

3.2 L'unité de calcul — Décryptage de w·x + b

Symbole Nom Rôle & interprétation

x Input (entrée) La valeur brute que le neurone reçoit. Ex : pixel d'image, valeur
d'un capteur, mot encodé.

w Poids (weight) Importance accordée à cet input. C'est ce que le réseau

apprend lors de l'entraînement. w fort = l'info est cruciale.

w·x Signal pondéré Produit scalaire entre entrée et son importance. Si w = 0, l'input
est ignoré. Si w < 0, effet inhibiteur.

b Biais (bias) Décalage indépendant des inputs. Permet au neurone de

s'activer même si tous les inputs sont à 0. Analogue à
l'ordonnée à l'origine y = ax + b.

Σwᵢxᵢ + b Pré-activation z Combinaison linéaire totale avant l'activation. Sans f(z), un

réseau de neurones ne serait qu'une régression linéaire.
 🎯 Analogie béton

w·x + b c'est exactement y = ax + b (droite en maths). Le neurone fait une régression

linéaire locale, puis la fonction d'activation introduit la non-linéarité indispensable pour
apprendre des patterns complexes.

3.3 Fonctions d'Activation

La fonction d'activation f(z) introduit la non-linéarité sans laquelle le réseau ne serait qu'une
transformation linéaire, incapable d'apprendre des frontières complexes.

Fonction Formule Sortie Quand l'utiliser

ReLU f(z) = max(0, z) [0, +∞) Par défaut dans les hidden
layers. Rapide, efficace, évite le
vanishing gradient.

Leaky ReLU f(z) = max(0.01z, z) (-∞, +∞) Quand ReLU "meurt" (dying
ReLU). Neurones qui ne
s'activent jamais à 0.

Sigmoid f(z) = 1 / (1 + e⁻ᶻ) [0, 1] Output layer classification

binaire. Interprétable comme
probabilité.

Tanh f(z) = (eᶻ - e⁻ᶻ) / (eᶻ + [-1, 1] Hidden layers RNN/LSTM.

e⁻ᶻ) Centré en 0 = meilleure
convergence que sigmoid.

Softmax f(zᵢ) = eᶻⁱ / Σeᶻʲ [0,1], somme = 1 Output layer classification multi-
classes. Convertit logits en
distribution de probabilité.

GELU Approx. gaussienne (-∞, +∞) Transformers (BERT, GPT).

Combinaison ReLU +
probabilité, très performante.

3.4 Architecture d'un Réseau de Neurones

INPUT LAYER HIDDEN LAYERS OUTPUT LAYER

x₁, x₂, ..., xₙ Layer 1 → Layer 2 → ... ŷ₁, ŷ₂, ..., ŷₖ
Reçoit les données brutes. Extraction de features Sigmoid (binaire), Softmax
Chaque neurone = 1 feature. hiérarchiques. ReLU (multi-classes), Linéaire
Pas d'activation. typiquement. Plus de couches = (régression). Produit la
plus de complexité. prédiction finale.

Taille = nb de features Choisies par expérimentation Taille = nb de classes

(hyperparamètre)

🎯 Analogie

L'input layer reçoit les ingrédients bruts. Les hidden layers sont les étapes de cuisine
(découpe, cuisson, assaisonnement). L'output layer est l'assiette finale servie au client.
3.5 Les 5 Étapes d'Entraînement d'un Réseau

1 FORWARD PROPAGATION
Les données x traversent le réseau couche par couche. Chaque neurone calcule z =
Σwᵢxᵢ + b puis applique f(z). La prédiction ŷ sort de l'output layer.

2 CALCUL DE LA LOSS (Fonction de perte)

On compare ŷ (prédit) à y (réel) via une fonction de perte :
MSE (régression): L = (1/n) Σ(yᵢ - ŷᵢ)² | Cross-Entropy
(classification): L = -Σ yᵢ log(ŷᵢ)
Plus L est faible, plus le modèle est précis. L'objectif : minimiser L.

3 BACKPROPAGATION
On calcule le gradient de L par rapport à chaque poids w via la règle de la chaîne
(chain rule). On propage l'erreur de l'output vers l'input.
∂L/∂w = ∂L/∂ŷ · ∂ŷ/∂z · ∂z/∂w (chain rule appliquée couche par
couche)

4 GRADIENT DESCENT (Descente de gradient)

On met à jour chaque poids dans la direction opposée au gradient :
w ← w - η · ∂L/∂w où η (eta) = learning rate (taux
d'apprentissage, ex : 0.001)
Optimiseurs courants : SGD, Adam (le plus utilisé), RMSProp, AdaGrad.

5 ITÉRATION — EPOCH
On répète les étapes 1 à 4 sur tous les mini-batches du dataset. Une epoch = 1
passage complet sur le dataset d'entraînement. On itère sur plusieurs
dizaines/centaines d'epochs jusqu'à convergence.
PARTIE 4 — VISION PAR ORDINATEUR

4.1 De la couleur au niveau de gris

Une image couleur est stockée en 3 canaux : Rouge (R), Vert (G), Bleu (B). Chaque pixel
contient 3 valeurs entières entre 0 et 255. Pour convertir en niveaux de gris, on effectue une
combinaison linéaire pondérée des 3 canaux, calibrée sur la perception humaine.

📐 Formule officielle ITU-R BT.601 (standard international)

I = 0.299 · R + 0.587 · G + 0.114 · B

I = intensité de gris (0 = noir, 255 = blanc)

Pourquoi ces coefficients ?

Canal Coefficient Explication perceptuelle

Rouge (R) 0.299 (~30%) L'oeil humain est moyennement sensible au rouge.

Vert (G) 0.587 (~59%) Le vert est la couleur pour laquelle l'oeil est le PLUS sensible
(cônes M dominants). C'est pourquoi il a le poids le plus
élevé.

Bleu (B) 0.114 (~11%) L'oeil est peu sensible au bleu. Il contribue le moins à la
luminosité perçue.

TOTAL 0.299 + 0.587 + La somme des coefficients vaut toujours 1 : la luminosité est
0.114 = 1.0 préservée.

🎯 Analogie

Si tu mélanges de la peinture R, G, B en proportions égales (33% chacune), tu obtiens un

gris neutre mais pas fidèle à ce qu'on perçoit. La formule 0.299/0.587/0.114 reproduit
comment notre cerveau perçoit la luminosité. Le vert nous apparaît 2x plus lumineux que le
rouge et 5x plus que le bleu.
Exemple de calcul concret

Couleur Valeurs RGB Calcul → Intensité de gris

Rouge pur R=255, G=0, B=0 0.299×255 + 0.587×0 + 0.114×0 = 76

Vert pur R=0, G=255, B=0 0.299×0 + 0.587×255 + 0.114×0 = 150

Bleu pur R=0, G=0, B=255 0.299×0 + 0.587×0 + 0.114×255 = 29

Blanc pur R=255, G=255, 0.299×255 + 0.587×255 + 0.114×255 = 255

B=255

Noir pur R=0, G=0, B=0 0.299×0 + 0.587×0 + 0.114×0 = 0

PARTIE 5 — EXEMPLE PRATIQUE : MLP avec
PyTorch
Implémentation complète d'un Multi-Layer Perceptron (MLP) pour la classification. Chaque
ligne est commentée pour comprendre le mapping avec la théorie.

5.1 Architecture & Entraînement complets

# ─────────────────────────────────────────────────────────────────────
# MLP COMPLET AVEC PYTORCH — Classification multi-classes
# ─────────────────────────────────────────────────────────────────────
import torch
import [Link] as nn
import [Link] as optim
from [Link] import DataLoader, TensorDataset
import numpy as np

# ─── 1. CRÉATION DES DONNÉES SYNTHÉTIQUES ─────────────────────────────

torch.manual_seed(42)
X = [Link](1000, 20) # 1000 exemples, 20 features (INPUT LAYER = 20
neurones)
y = [Link](0, 3, (1000,)) # 3 classes (OUTPUT LAYER = 3 neurones +
Softmax)

# ─── 2. DATALOADER — mini-batch gradient descent ──────────────────────

dataset = TensorDataset(X, y)
loader = DataLoader(dataset, batch_size=32, shuffle=True)

# ─── 3. ARCHITECTURE DU MLP ────────────────────────────────────────────

class MLP([Link]):
def __init__(self, input_dim, hidden_dims, output_dim):
super().__init__()
# Construire les couches dynamiquement
layers = []
prev_dim = input_dim

for hidden_dim in hidden_dims:

 [Link]([Link](prev_dim, hidden_dim)) # z = w*x + b
[Link]([Link]()) # f(z) = max(0, z)
[Link]([Link](0.3)) # Régularisation anti-overfitting
prev_dim = hidden_dim

[Link]([Link](prev_dim, output_dim)) # Couche de sortie

# PAS de Softmax ici → [Link] l'inclut (LogSoftmax + NLLLoss)

[Link] = [Link](*layers)

def forward(self, x):

return [Link](x) # Forward propagation complète

# ─── 4. INSTANCIATION ───────────────────────────────────────────────────

# Input: 20 → Hidden: [128, 64, 32] → Output: 3
model = MLP(input_dim=20, hidden_dims=[128, 64, 32], output_dim=3)
criterion = [Link]() # Loss = -Σ yᵢ log(ŷᵢ)
optimizer = [Link]([Link](), lr=1e-3) # η = 0.001

# ─── 5. BOUCLE D'ENTRAÎNEMENT ───────────────────────────────────────────

EPOCHS = 20
for epoch in range(EPOCHS):
[Link]()
total_loss = 0

for X_batch, y_batch in loader:

# FORWARD PASS
logits = model(X_batch) # ŷ = f(w*x + b)

# LOSS COMPUTATION
loss = criterion(logits, y_batch) # L = CrossEntropy(ŷ, y)

# BACKWARD PASS (backpropagation)

optimizer.zero_grad() # Reset des gradients accumulés
[Link]() # ∂L/∂w pour chaque paramètre (chain rule)

# GRADIENT DESCENT — mise à jour des poids

[Link]() # w ← w - η * ∂L/∂w

total_loss += [Link]()
 avg_loss = total_loss / len(loader)
if (epoch + 1) % 5 == 0:
print(f'Epoch [{epoch+1:2d}/{EPOCHS}] | Loss: {avg_loss:.4f}')

# ─── 6. ÉVALUATION ──────────────────────────────────────────────────────

[Link]()
with torch.no_grad(): # Pas de gradient en inférence
logits = model(X)
probs = [Link](logits, dim=1) # Softmax → probabilités
preds = [Link](probs, dim=1) # Classe avec proba max
accuracy = (preds == y).float().mean()
print(f'Accuracy: {accuracy:.4f} ({accuracy*100:.1f}%)')

# ─── 7. INSPECTER LE MODÈLE ─────────────────────────────────────────────

print(model)
total_params = sum([Link]() for p in [Link]())
print(f'Paramètres totaux (poids + biais): {total_params:,}')

5.2 Anatomie du code — Mapping Théorie ↔ Code

Concept théorique Code PyTorch Explication

z = Σwᵢxᵢ + b [Link](in, out) Créé les poids w et biais b

automatiquement

f(z) = ReLU [Link]() Applique max(0, z) element-wise

Loss L [Link]() Inclut LogSoftmax + NLLLoss

Backprop ∂L/∂w [Link]() Calcule tous les gradients

(autograd)

w ← w - η·∇L [Link]() Mise à jour des poids selon Adam

Reset gradient optimizer.zero_grad() PyTorch accumule par défaut →

reset nécessaire
RÉCAPITULATIF & FEUILLE DE ROUTE

Ce que tu maîtrises maintenant

Concept Points clés retenus

Data Science Cycle en 8 étapes, 4 métiers, écosystème

complet

Deep Learning vs ML Feature engineering auto, besoin de data, GPU,

boîte noire

Neurone artificiel z = Σwᵢxᵢ + b → f(z) = ŷ, rôle de w, x, b

Fonctions d'activation ReLU (hidden), Sigmoid (binaire), Softmax (multi-

classes)

Entraînement Forward → Loss → Backprop → Gradient

Descent → Epoch

Vision — Niveaux de gris I = 0.299R + 0.587G + 0.114B (perception

humaine)

Prochaines étapes pour devenir pro

1. CNN (Convolutional Neural Networks) : Vision par ordinateur avancée. Couches

Conv2D, MaxPool, BatchNorm. Projets : classification d'images, détection d'objets
(YOLO).
2. RNN / LSTM / Transformers : Séquences et texte. BERT pour le NLP, GPT pour la
génération. Fine-tuning de modèles pré-entraînés (Hugging Face).
3. Régularisation & optimisation : Dropout, BatchNorm, Weight Decay, Learning Rate
Scheduling, Early Stopping. Clés contre l'overfitting.
4. MLOps & déploiement : FastAPI, Docker, TorchServe, ONNX pour exporter. GitHub
Actions pour CI/CD. Monitoring avec Evidently ou WhyLabs.
5. Projets concrets : Kaggle competitions, reproduction de papers, contribution open
source. La pratique > la théorie.
La théorie sans pratique est stérile. Code tous les jours.
Cours Data Science & Deep Learning — Tous droits réservés