Vue d'ensemble

Programme de Formation ML Détaillé

Informations Clés

📅 Début : 1er Février 2026

⏰ Durée : 4h/semaine pendant 1 mois

💻 Plateforme : Google Colab

🎯 Niveau : Débutants Complets

🌟 Points Forts de la Formation

100% Pratique : Chaque session inclut des exercices sur Google Colab
Aucun prérequis : Parfait pour débutants complets en ML
Projet Final : 3 options de projets pour votre portfolio
Certificat : Certificat de réussite à la fin
Support : Accompagnement personnalisé 7j/7

📚 Semaine 1 : Fondations

Introduction au Machine Learning et manipulation de tensors PyTorch

Session 1 (2h) : Introduction au ML + Tensors PyTorch

🎓 Théorie (45 min)

ML en analogie simple (15 min) :

"Programmation normale" : règles explicites
"Machine Learning" : apprendre des exemples
Exemples concrets : Netflix, Google Photos, autocorrect

Tensors PyTorch (30 min) :

Qu'est-ce qu'un tensor ? (tableau multi-dimensionnel)
Dimensions : scalaire (0D), vecteur (1D), matrice (2D), cube (3D)
Analogie : boîtes dans des boîtes

💻 Pratique (1h15) sur Colab

Setup Colab (15 min) :

# Vérification PyTorch
import torch
print(torch.__version__)
print("GPU disponible:", torch.cuda.is_available())
                    

Manipulation tensors (45 min) :

# Création de tensors
scalar = torch.tensor(5.0)
vector = torch.tensor([1.0, 2.0, 3.0])
matrix = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

# Opérations de base
a = torch.tensor([1.0, 2.0, 3.0])
b = torch.tensor([4.0, 5.0, 6.0])
c = a + b  # Addition
d = a * 2  # Multiplication

# Forme et dimensions
print("Shape:", matrix.shape)
print("Number of dimensions:", matrix.dim())
                    

Exercice guidé (15 min) :

Créer un tensor pour 10 étudiants avec 3 notes chacun
Calculer la moyenne par étudiant
Trouver la meilleure note

Session 2 (2h) : Apprentissage Supervisé + Régression

🎓 Théorie (45 min)

Apprentissage supervisé (20 min) :

Données étiquetées : input → output connu
Exemple : taille (input) → poids (output)
Deux types : Régression (nombres) vs Classification (catégories)

Régression linéaire (25 min) :

Problème : trouver la meilleure ligne droite
Équation : y = w*x + b (pente et origine)
Comment mesurer l'erreur ? → MSE (Mean Squared Error)
Comment améliorer ? → Descente de gradient (concept simple)

💻 Pratique (1h15)

Régression linéaire simple (40 min) :

# Dataset simple (taille vs poids)
tailles = torch.tensor([150., 160., 170., 180., 190.]).reshape(-1, 1)
poids = torch.tensor([50., 60., 70., 80., 90.]).reshape(-1, 1)

# Modèle PyTorch
class ModeleLineaire(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.w = torch.nn.Parameter(torch.randn(1, requires_grad=True))
        self.b = torch.nn.Parameter(torch.randn(1, requires_grad=True))
    
    def forward(self, x):
        return self.w * x + self.b

# Entraînement
modele = ModeleLineaire()
optimiseur = torch.optim.SGD(modele.parameters(), lr=0.01)

for epoch in range(100):
    predictions = modele(tailles)
    erreur = torch.mean((predictions - poids)**2)  # MSE
    
    optimiseur.zero_grad()
    erreur.backward()
    optimiseur.step()
                    

📚 Semaine 2 : Classification et Réseaux de Neurones

Découverte de la classification et architecture des réseaux profonds

Session 3 (2h) : Classification Binaire et Multi-classe

🎓 Théorie (45 min)

Classification binaire (20 min) :

2 classes seulement : OUI/NON, SPAM/NON-SPAM
Fonction sigmoïde : transforme en probabilité (0 à 1)
Perte : BCE (Binary Cross Entropy)

Classification multi-classe (25 min) :

Plusieurs classes : chat/chien/oiseau
Softmax : transforme en probabilités qui somment à 1
Perte : Cross Entropy

💻 Pratique (1h15)

Classification binaire (35 min) :

# Dataset : Points dans un cercle
n_points = 100
X = torch.randn(n_points, 2)
Y = (X[:, 0]**2 + X[:, 1]**2 < 1).float().reshape(-1, 1)

class ClassifieurBinaire(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.couche = torch.nn.Linear(2, 1)
        self.sigmoid = torch.nn.Sigmoid()
    
    def forward(self, x):
        return self.sigmoid(self.couche(x))

modele = ClassifieurBinaire()
perte = torch.nn.BCELoss()
                    

Session 4 (2h) : Deep Learning - Concepts de Base

🎓 Théorie (45 min)

Neurone artificiel (15 min) :

Analogie neurone biologique
Poids (importance) + biais (seuil)
Fonction d'activation (décision)

Architecture multi-couches (15 min) :

Pourquoi plusieurs couches ?
Chaque couche apprend des motifs différents
Exemple : pixels → bords → formes → objets

Fonctions d'activation (15 min) :

ReLU : simple et efficace (max(0, x))
Sigmoid : pour probabilités (0 à 1)
Tanh : comme sigmoid mais (-1 à 1)

💻 Pratique (1h15)

Réseau 2 couches (45 min) :

class Reseau2Couches(torch.nn.Module):
    def __init__(self, n_entree, n_cachee, n_sortie):
        super().__init__()
        self.couche1 = torch.nn.Linear(n_entree, n_cachee)
        self.couche2 = torch.nn.Linear(n_cachee, n_sortie)
        self.relu = torch.nn.ReLU()
        self.softmax = torch.nn.Softmax(dim=1)
    
    def forward(self, x):
        x = self.relu(self.couche1(x))
        x = self.couche2(x)
        return self.softmax(x)

# Test sur données simples
modele = Reseau2Couches(2, 10, 3)
                    

📚 Semaine 3 : Techniques Avancées

Optimisation, régularisation et applications pratiques

Session 5 (2h) : Optimisation et Régularisation

🎓 Théorie (45 min)

Optimiseurs avancés (15 min) :

SGD : simple mais lent
Adam : adapte le learning rate automatiquement
RMSprop : bon pour problèmes non-stationnaires

BatchNorm et Dropout (15 min) :

BatchNorm : normalise les activations (stabilise)
Dropout : désactive aléatoirement des neurones (évite le sur-apprentissage)

💻 Pratique (1h15)

BatchNorm et Dropout (45 min) :

class ReseauAvance(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.couche1 = torch.nn.Linear(10, 20)
        self.bn1 = torch.nn.BatchNorm1d(20)
        self.dropout1 = torch.nn.Dropout(0.3)
        self.couche2 = torch.nn.Linear(20, 10)
        self.relu = torch.nn.ReLU()
    
    def forward(self, x):
        x = self.relu(self.bn1(self.couche1(x)))
        x = self.dropout1(x)
        x = self.couche2(x)
        return x
                    

Session 6 (2h) : Application Deep Learning

Session entièrement pratique avec applications complètes

💻 Pratique complète (2h)

Régression non-linéaire avancée (1h)

Classification binaire avancée (1h)

📚 Semaine 4 : Projets et Consolidation

Classification avancée et projet final

Session 7 (2h) : Classification Multi-classe + Récapitulatif

💻 Pratique (1h) - MNIST

# MNIST simplifié (chiffres manuscrits)
from torchvision import datasets, transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_set = datasets.MNIST('./data', download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=32, shuffle=True)

class CNN_MNIST(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = torch.nn.Conv2d(1, 16, 3, padding=1)
        self.conv2 = torch.nn.Conv2d(16, 32, 3, padding=1)
        self.pool = torch.nn.MaxPool2d(2, 2)
        self.fc1 = torch.nn.Linear(32*7*7, 128)
        self.fc2 = torch.nn.Linear(128, 10)
        self.relu = torch.nn.ReLU()
        self.dropout = torch.nn.Dropout(0.3)
    
    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = x.view(-1, 32*7*7)
        x = self.dropout(self.relu(self.fc1(x)))
        return self.fc2(x)
                    

📝 Attribution projet final (30 min)

3 options au choix :

Projet 1 : Prédicteur de prix de maisons (Boston Housing)
Projet 2 : Classifieur de vêtements (Fashion MNIST)
Projet 3 : Classifieur de sentiments (texte simple)

Session 8 (2h) : Présentations Projets Finals

🎤 Structure (2h)

Préparation (15 min) : Derniers ajustements
Présentations (1h30) : 10 min par personne
- 5 min présentation
- 3 min démo
- 2 min questions
Feedback et suite (15 min) : Comment continuer, ressources, certificats

📚 Ressources Google Colab

Notebooks interactifs pour chaque session

🔗 Liens directs (à créer) :

Session 1 : [Colab - Tensors Basics]
Session 2 : [Colab - Régression]
Session 3 : [Colab - Classification]
Session 4 : [Colab - Deep Learning Basics]
Session 5 : [Colab - Optimisation]
Session 6 : [Colab - Applications]
Session 7 : [Colab - MNIST + Projet]
Session 8 : [Colab - Template Présentation]

📝 Instructions pour chaque session :

Avant : Ouvrir Colab, faire une copie dans Drive, lire objectifs
Pendant : Suivre pas à pas, modifier paramètres, poser questions
Après : Ré-exécuter tout, faire exercices bonus

🎯 Évaluation et Suivi

✅ Checkpoints chaque semaine :

Fin Semaine 1 : Savoir manipuler des tensors
Fin Semaine 2 : Pouvoir expliquer régression/classification
Fin Semaine 3 : Savoir régulariser un modèle
Fin Semaine 4 : Avoir un projet fonctionnel

⭐ Critères projet final :

Fonctionnel (40%) : Le code tourne sans erreur
Compréhension (30%) : Peut expliquer chaque partie
Originalité (20%) : Petite amélioration personnelle
Présentation (10%) : Clarté et structure

💡 Conseils pour réussir

Ne pas sauter les bases : Même si c'est tentant
Pratiquer entre sessions : 30 min tous les 2 jours

Poser des questions : Aucune question n'est bête
Refaire sans regarder : Après avoir compris

Prêt à commencer votre parcours ML ?

Voir toutes les formations Nous contacter

Contact

+213 782 686 559

aidzacademy@gmail.com

Programme ML Détaillé

Vue d'ensemble

Programme de Formation ML Détaillé

Informations Clés

🌟 Points Forts de la Formation

📚 Semaine 1 : Fondations

Session 1 (2h) : Introduction au ML + Tensors PyTorch

🎓 Théorie (45 min)

ML en analogie simple (15 min) :

Tensors PyTorch (30 min) :

💻 Pratique (1h15) sur Colab

Setup Colab (15 min) :

Manipulation tensors (45 min) :

Exercice guidé (15 min) :

Session 2 (2h) : Apprentissage Supervisé + Régression

🎓 Théorie (45 min)

Apprentissage supervisé (20 min) :

Régression linéaire (25 min) :

💻 Pratique (1h15)

Régression linéaire simple (40 min) :

📚 Semaine 2 : Classification et Réseaux de Neurones

Session 3 (2h) : Classification Binaire et Multi-classe

🎓 Théorie (45 min)

Classification binaire (20 min) :

Classification multi-classe (25 min) :

💻 Pratique (1h15)

Classification binaire (35 min) :

Session 4 (2h) : Deep Learning - Concepts de Base

🎓 Théorie (45 min)

Neurone artificiel (15 min) :

Architecture multi-couches (15 min) :

Fonctions d'activation (15 min) :

💻 Pratique (1h15)

Réseau 2 couches (45 min) :

📚 Semaine 3 : Techniques Avancées

Session 5 (2h) : Optimisation et Régularisation

🎓 Théorie (45 min)

Optimiseurs avancés (15 min) :

BatchNorm et Dropout (15 min) :

💻 Pratique (1h15)

BatchNorm et Dropout (45 min) :

Session 6 (2h) : Application Deep Learning

💻 Pratique complète (2h)

Régression non-linéaire avancée (1h)

Classification binaire avancée (1h)

📚 Semaine 4 : Projets et Consolidation

Session 7 (2h) : Classification Multi-classe + Récapitulatif

💻 Pratique (1h) - MNIST

📝 Attribution projet final (30 min)

3 options au choix :

Session 8 (2h) : Présentations Projets Finals

🎤 Structure (2h)

📚 Ressources Google Colab

🔗 Liens directs (à créer) :

📝 Instructions pour chaque session :

🎯 Évaluation et Suivi

✅ Checkpoints chaque semaine :

⭐ Critères projet final :

💡 Conseils pour réussir

Prêt à commencer votre parcours ML ?

Contact