Parcours · Algorithmes & IA
Algorithmes & IA
Comprendre comment pense une machine : 68 leçons progressives, des tout premiers algorithmes (variables, conditions, boucles, fonctions) aux structures de données, au tri et à la complexité, puis aux vecteurs, aux arbres de décision et aux réseaux de neurones. Aucun prérequis : on part de zéro.
- leçons
- 68
- modules
- 9
- ateliers Python
- 68
Ce parcours compte pour plusieurs certifications
Toutes les certifications- Praticien du machine learning (Fondamentaux)11 leçons
- Praticien du machine learning (Avancé)5 leçons
- Développeur Python data (Avancé)9 leçons
Chaque niveau demande des leçons de plusieurs parcours, puis un examen final corrigé sur nos serveurs. Le diagnostic et le plan de révision sont ouverts sans abonnement.
Certification Central Campus : ni diplôme d'État, ni certification professionnelle enregistrée au répertoire national.
Progression
Trois paliers, sans trou dans la compréhension
Chaque module s'appuie sur le précédent. En suivant l'ordre, on passe naturellement du raisonnement algorithmique de base à l'intelligence artificielle.
01
Débutant
Qu'est-ce qu'un algorithme : variables, conditions, boucles, fonctions et décomposition d'un problème.
02
Intermédiaire
Structures de données, mesure de la complexité (Big-O), algorithmes de tri et de recherche.
03
Expert
Paradigmes, vecteurs et maths pour l'IA, régression, arbres de décision et réseaux de neurones.
Les fondations : qu'est-ce qu'un algorithme ?
DébutantLe socle de tout : comprendre ce qu'est un algorithme, manipuler des variables, enchaîner des instructions, prendre des décisions avec des conditions et répéter des actions avec les boucles POUR et TANT QUE.
6 leçons
Qu'est-ce qu'un algorithme ?
Une suite d'étapes précises pour résoudre un problème : la recette de cuisine de l'informatique, indépendante du langage.
Ouvrir la leçonVariables et données
Stocker une information dans une « boîte » nommée pour la réutiliser et la modifier : le réflexe de base de tout programme.
Ouvrir la leçonLa séquence : enchaîner des instructions
L'exécution se fait ligne après ligne, de haut en bas, et l'ordre change tout, surtout quand une étape réutilise le résultat de la précédente.
Ouvrir la leçonLes conditions : prendre une décision (si / sinon)
Faire bifurquer le programme selon qu'un test est vrai ou faux : la toute première forme d'« arbre de décision ».
Ouvrir la leçonLes boucles : répéter une action
Répéter automatiquement des instructions avec la boucle POUR et un accumulateur : le cœur de la puissance des machines.
Ouvrir la leçonLa boucle TANT QUE : répéter jusqu'à une condition
Répéter un traitement tant qu'une condition reste vraie, quand on ne connaît pas le nombre de tours, sans jamais tomber dans la boucle infinie.
Ouvrir la leçonFonctions et abstraction
DébutantRéutiliser du code grâce aux fonctions, maîtriser paramètres et valeur de retour, décomposer un problème, le tester sur ses cas limites, et comprendre la récursivité : une fonction qui s'appelle elle-même.
6 leçons
Les fonctions : des boîtes réutilisables
Regrouper des instructions sous un nom pour les exécuter à volonté sans les réécrire : le premier pas vers un code organisé et sans répétition.
Ouvrir la leçonParamètres et valeur de retour
Rendre une fonction générique grâce aux paramètres et lui faire produire un résultat utilisable avec RETOURNER.
Ouvrir la leçonDécomposer un problème en sous-problèmes
Découper un problème complexe en fonctions indépendantes, plus simples à écrire, tester et réutiliser : le cœur de la conception algorithmique.
Ouvrir la leçonTester un algorithme : cas normaux, cas limites, assertions
Vérifier qu'un algorithme est juste avant de lui faire confiance : choisir ses cas de test, écrire des assertions et corriger ce qu'elles révèlent.
Ouvrir la leçonLa récursivité : une fonction qui s'appelle elle-même
Comprendre qu'une fonction peut s'appeler elle-même pour résoudre un problème par autoréférence, à condition d'avoir un cas de base qui stoppe la chaîne.
Ouvrir la leçonRécursivité en pratique : chiffres, puissance rapide, arborescences
Appliquer la récursivité à des problèmes concrets : additionner les chiffres d'un nombre, calculer une puissance en peu de multiplications, parcourir des dossiers.
Ouvrir la leçonStructures de données
IntermédiaireChoisir la bonne structure avant d'écrire l'algorithme : tableaux pour l'accès par position, pile et file pour contrôler l'ordre de traitement, dictionnaires et ensembles pour retrouver une donnée sans tout parcourir, tas pour servir le plus urgent, arbres et graphes pour les hiérarchies et les réseaux.
8 leçons
Tableaux et listes : des données ordonnées
Ranger plusieurs valeurs sous un seul nom, y accéder par un indice qui commence à 0 et les parcourir avec une boucle pour calculer une moyenne, un maximum et sa position.
Ouvrir la leçonPiles et files : LIFO et FIFO
Deux structures qui imposent l'ordre de sortie : la pile rend le dernier élément entré, la file le premier. Pratique : vérifier qu'une expression a des parenthèses équilibrées avec une pile.
Ouvrir la leçonFiles d'attente (FIFO) avec deque
Traiter des demandes dans leur ordre d'arrivée, même quand de nouvelles arrivent pendant le traitement : simulation d'une file de tickets de support avec collections.deque.
Ouvrir la leçonDictionnaires et tables de hachage (clé → valeur)
Retrouver une valeur par sa clé sans parcourir toute la collection : fonctionnement d'une table de hachage, coût moyen et pire cas, et le motif du comptage de fréquences.
Ouvrir la leçonEnsembles : doublons, appartenance, intersection
Dédoublonner une liste, tester l'appartenance sans tout parcourir et croiser deux listes de clients par intersection, différence et union : les ensembles et leurs opérations.
Ouvrir la leçonTas binaire et file de priorité
Toujours servir l'élément le plus urgent, même quand il arrive en dernier : le tas binaire, son rangement dans un tableau, et la file de priorité avec heapq.
Ouvrir la leçonLes arbres : organiser une hiérarchie
Modéliser une hiérarchie avec des nœuds, chercher dans un arbre binaire de recherche et mesurer sa hauteur : rapide quand l'arbre est équilibré, lent quand il dégénère en liste.
Ouvrir la leçonLes graphes : modéliser des réseaux
Représenter un réseau de villes, de personnes ou de tâches par des sommets et des arêtes, choisir entre liste et matrice d'adjacence, et calculer le degré de chaque sommet.
Ouvrir la leçonComplexité et efficacité
IntermédiaireMesurer le coût d'un algorithme en temps et en mémoire, lire une notation O, Ω ou Θ, reconnaître les grandes classes de complexité, connaître le coût réel des opérations Python et arbitrer entre vitesse et espace.
5 leçons
Mesurer l'efficacité : compter les opérations
Pas de chronomètre, qui dépend de la machine : on fixe un modèle de comptage et l'on compte les opérations élémentaires selon la taille n pour obtenir T(n).
Ouvrir la leçonLes notations O, Ω et Θ
Garder le terme dominant, effacer les constantes, et distinguer borne supérieure O, borne inférieure Ω et borne exacte Θ, qui s'appliquent à n'importe quel cas.
Ouvrir la leçonLes grandes classes : de O(1) à O(n!)
Reconnaître d'un coup d'œil O(1), O(log n), O(n), O(n log n), O(n²), O(2^n) et O(n!) dans un algorithme, et savoir ce que chaque classe permet en pratique.
Ouvrir la leçonLe coût réel des opérations Python
append en O(1) amorti, insert(0) et pop(0) en O(n), « in » sur une liste ou sur un set, tranches qui copient : la bonne structure change la classe.
Ouvrir la leçonTemps contre espace : les compromis
La complexité mémoire complète la complexité en temps : avec Fibonacci, comparer la récursion naïve, la mémoïsation et la version itérative à deux variables.
Ouvrir la leçonTri et recherche
IntermédiaireChercher une valeur dans une collection et trier des données : du balayage linéaire à la dichotomie et à ses variantes, des tris simples aux tris en O(n log n), jusqu'à l'usage professionnel de sorted.
8 leçons
La recherche linéaire
Parcourir un tableau élément par élément jusqu'à trouver la cible ou épuiser la liste : la méthode qui marche partout, trié ou non, en O(n) dans le pire cas.
Ouvrir la leçonLa recherche dichotomique (binaire)
Sur un tableau trié, comparer la cible à l'élément du milieu et éliminer la moitié de l'intervalle à chaque étape : 20 itérations au plus pour un million.
Ouvrir la leçonDichotomie : première occurrence, bisect et recherche sur la réponse
Trouver la première occurrence dans un tableau trié avec doublons, utiliser bisect_left, puis chercher la plus petite valeur qui satisfait une contrainte.
Ouvrir la leçonLe tri par sélection
Chercher le minimum de la partie non triée et le placer en tête, passe après passe : toujours n(n − 1)/2 comparaisons, au plus n − 1 échanges, non stable.
Ouvrir la leçonLe tri par insertion
Insérer chaque élément à sa place dans la partie déjà triée en décalant les plus grands : un tri stable et adaptatif, linéaire sur des données presque triées.
Ouvrir la leçonLe tri fusion (diviser pour régner)
Couper le tableau en deux, trier chaque moitié récursivement, puis fusionner deux listes triées : O(n log n) dans tous les cas, stable, avec O(n) de mémoire.
Ouvrir la leçonLe tri rapide (quicksort)
Choisir un pivot, ranger les plus petits à sa gauche et les plus grands à sa droite, puis trier chaque côté : O(n log n) en moyenne, O(n²) si le pivot est mauvais.
Ouvrir la leçonTrier en pratique : sorted, key, stabilité, tri multicritère
En production, on ne réécrit pas un tri : sorted avec key et reverse, la stabilité pour les tris multicritères, et le tri par comptage quand il fait mieux.
Ouvrir la leçonParadigmes algorithmiques
ExpertLes grandes stratégies de conception : diviser pour régner, deux pointeurs, algorithmes gloutons, programmation dynamique (escalier, sac à dos, distance d'édition), retour sur trace, puis les graphes : parcours, plus court chemin pondéré et tri topologique.
10 leçons
Diviser pour régner
Découper un problème en sous-problèmes indépendants, les résoudre récursivement puis combiner : maximum d'un tableau et comptage des inversions entre deux classements.
Ouvrir la leçonDeux pointeurs et fenêtre glissante
Parcourir un tableau une seule fois avec deux indices : meilleure semaine de ventes, plus courte période qui atteint un objectif et paire de montants égale à un budget.
Ouvrir la leçonLes algorithmes gloutons
Faire à chaque étape le meilleur choix local, sans revenir en arrière : rapide et parfois optimal, comme pour planifier des réunions, parfois faux, comme pour rendre la monnaie avec des pièces inhabituelles.
Ouvrir la leçonLa programmation dynamique
Mémoriser les résultats de sous-problèmes qui se répètent : la méthode en quatre étapes (état, transition, cas de base, ordre de remplissage) appliquée aux façons de monter un escalier.
Ouvrir la leçonLe sac à dos 0/1 par programmation dynamique
Choisir des projets sous contrainte de budget pour maximiser la valeur : table dp[i][w] remplie pas à pas, reconstruction des choix et contre-exemple du glouton par ratio.
Ouvrir la leçonDistance d'édition (Levenshtein)
Compter le nombre minimal d'insertions, suppressions et substitutions entre deux mots : dédoublonner des noms de clients mal saisis et proposer une correction orthographique.
Ouvrir la leçonLe retour sur trace (backtracking)
Explorer les choix possibles un par un et revenir en arrière dès qu'une branche mène à une impasse : la technique derrière les labyrinthes, le Sudoku et les problèmes de placement.
Ouvrir la leçonParcourir un graphe : BFS et DFS
Visiter tous les sommets accessibles d'un graphe : le parcours en largeur (BFS, avec une file) donne les distances en nombre d'arêtes, le parcours en profondeur (DFS, pile ou récursion) plonge le plus loin possible.
Ouvrir la leçonPlus court chemin pondéré : Dijkstra
Calculer les temps de trajet minimaux depuis un entrepôt quand les routes n'ont pas toutes la même durée : file de priorité, relâchement des arêtes et reconstruction du chemin.
Ouvrir la leçonTri topologique : ordonner des tâches dépendantes
Trouver un ordre d'exécution qui respecte toutes les dépendances d'un pipeline de données, comme le font Airflow et dbt, et détecter un cycle qui rend tout ordre impossible.
Ouvrir la leçonMaths pour l'IA : vecteurs et fonctions
ExpertLes briques mathématiques de l'apprentissage automatique, expliquées simplement : vecteurs, distances, similarité cosinus, matrices, fonctions, fonction de coût, dérivées et descente de gradient.
8 leçons
Les vecteurs : représenter des données
Un vecteur est une liste de nombres qui décrit un objet. Mesurez la ressemblance de deux maisons par la distance euclidienne et découvrez l'effet d'échelle.
Ouvrir la leçonOpérations sur les vecteurs : norme et produit scalaire
Addition, multiplication par un scalaire, norme et produit scalaire : les quatre opérations vectorielles de base du machine learning, calculées composante par composante.
Ouvrir la leçonSimilarité cosinus : comparer des textes et des embeddings
Classer des documents par pertinence avec la similarité cosinus, comme l'étape de recherche d'un RAG : produit scalaire divisé par les normes, insensible à la longueur.
Ouvrir la leçonMatrices : produit matrice-vecteur et matrice-matrice
Une matrice est un tableau de nombres en lignes et colonnes. Calculez un chiffre d'affaires par magasin et la sortie d'une couche de neurones W·x + b.
Ouvrir la leçonLes fonctions mathématiques (et la fonction linéaire)
f(x) associe une sortie à chaque entrée ; la fonction linéaire y = a·x + b, sa pente et son ordonnée à l'origine, et comment retrouver la droite à partir de deux points.
Ouvrir la leçonLa fonction de coût : mesurer l'erreur
Comparer prédictions et réalité avec l'erreur quadratique moyenne (EQM), l'erreur absolue moyenne (MAE) et la RMSE, puis choisir le meilleur de deux modèles.
Ouvrir la leçonDérivée et gradient : d'où vient la direction de descente ?
La dérivée mesure la pente locale d'une fonction. Comparez dérivée numérique et dérivée exacte, puis calculez le gradient de l'EQM d'une droite selon a et b.
Ouvrir la leçonLa descente de gradient : apprendre en optimisant
Descendre la pente d'un vrai coût f(a) = (a − 3)² pas à pas ; le rôle du taux d'apprentissage, de la convergence vers le minimum à la divergence en oscillant.
Ouvrir la leçonMachine learning supervisé
ExpertApprendre à partir d'exemples étiquetés, et le mesurer honnêtement : découpage entraînement, validation et test, régression et classification, métriques, normalisation, k plus proches voisins, arbres de décision et méthodes d'ensemble, tout codé à la main en Python standard.
10 leçons
Qu'est-ce que le machine learning ?
Apprendre une règle à partir d'exemples plutôt que l'écrire à la main : étiquettes, jeu d'entraînement et jeu de test, et la référence constante qu'un modèle doit battre.
Ouvrir la leçonEntraînement, validation, test et fuite de données
Découper un jeu de données sans tricher : mélange reproductible, découpage 60/20/20, validation croisée à k plis, fuite de données et découpage chronologique des séries temporelles.
Ouvrir la leçonLa régression linéaire : prédire un nombre
Ajuster la droite qui prédit un prix à partir d'une surface : erreur quadratique moyenne, descente de gradient sur des données centrées-réduites et solution exacte des moindres carrés.
Ouvrir la leçonLa classification et la régression logistique
Prédire une catégorie plutôt qu'un nombre : score linéaire, fonction sigmoïde, probabilité entre 0 et 1, frontière de décision et choix du seuil selon le coût des erreurs.
Ouvrir la leçonMatrice de confusion, précision, rappel et F1
Évaluer un classifieur au-delà de l'exactitude : matrice de confusion, précision, rappel, score F1, piège des classes déséquilibrées et compromis obtenu en faisant varier le seuil.
Ouvrir la leçonNormaliser les caractéristiques : min-max et centrage-réduction
Mettre les variables à la même échelle avant un calcul de distance : mise à l'échelle min-max, centrage-réduction, paramètres appris sur l'entraînement seul et garde-fou pour une colonne constante.
Ouvrir la leçonLes k plus proches voisins (k-NN)
Classer un point d'après ses k voisins les plus proches : distance euclidienne, tri, vote majoritaire avec départage explicite, effet du choix de k et rôle de la normalisation.
Ouvrir la leçonLes arbres de décision
Une suite de questions oui ou non pour classer un exemple : nœuds, branches, feuilles, traduction directe en SI/SINON imbriqués et test des frontières de chaque question.
Ouvrir la leçonChoisir une question : impureté de Gini et gain
Comment un arbre choisit ses questions : impureté de Gini d'un nœud, Gini pondéré d'un découpage, gain, choix glouton de la meilleure question et découpage dégénéré à écarter.
Ouvrir la leçonForêts aléatoires et boosting (méthodes d'ensemble)
Combiner plusieurs arbres pour dépasser leurs limites : vote majoritaire d'une forêt aléatoire, puis gradient boosting qui ajuste chaque nouvel arbre sur les résidus des précédents.
Ouvrir la leçonApprentissage non supervisé et réseaux de neurones
ExpertRegrouper des données sans étiquettes (k-means), résumer deux variables corrélées en un axe (ACP), calculer un neurone puis un réseau, l'entraîner par rétropropagation, comprendre l'attention des LLM, et finir par le diagnostic du surapprentissage et des biais.
7 leçons
L'apprentissage non supervisé et le clustering (k-means)
Sans étiquettes, l'algorithme regroupe ce qui se ressemble. Le k-means alterne affectation des points au centre le plus proche et recalcul des centres, jusqu'à stabilité.
Ouvrir la leçonLa réduction de dimension (ACP)
Deux variables corrélées racontent presque la même chose. L'ACP trouve l'axe qui capture le plus de variance : on le calcule à la main sur deux notes, valeurs propres comprises.
Ouvrir la leçonLe neurone artificiel (perceptron)
Entrées × poids + biais, puis fonction d'activation : le neurone artificiel est la brique de tous les réseaux. On le calcule sur trois entrées, dont le cas limite z = 0.
Ouvrir la leçonLes réseaux de neurones
Empiler des couches de neurones pour obtenir des frontières non linéaires. On calcule à la main la propagation avant d'un réseau 3 → 2 → 1, couche par couche, sur trois entrées.
Ouvrir la leçonLa rétropropagation pas à pas
Comment un réseau corrige ses poids : propagation avant, dérivation en chaîne jusqu'à chaque poids, mise à jour, et contrôle du gradient analytique par un gradient numérique.
Ouvrir la leçonEmbeddings et attention : l'algorithmique derrière les LLM
Un mot devient un vecteur, puis chaque mot regarde les autres : on calcule à la main les scores d'attention, un softmax stable et la moyenne pondérée qui forme la sortie.
Ouvrir la leçonBien apprendre : surapprentissage, validation et biais
Comparer l'exactitude d'entraînement et de test pour diagnostiquer surapprentissage et sous-apprentissage, puis mesurer un écart d'équité entre groupes avant tout déploiement.
Ouvrir la leçon