ML, Deep Learning, LLM – les vraies differences

Machine Learning, Deep Learning, LLM — ces trois termes circulent partout et sont souvent utilisés de façon interchangeable, même par des ingénieurs expérimentés. Le résultat : des choix technologiques incorrects, des architectures mal adaptées, et des projets qui échouent non pas à cause du code, mais à cause d’un mauvais diagnostic du problème.

Dans cette leçon, on va démêler ces trois concepts une fois pour toutes — avec des définitions précises, des exemples concrets en .NET, et un framework de décision pour savoir lequel choisir selon ton cas d’usage.

La hiérarchie fondamentale

Avant tout, comprends que ces trois concepts s’emboîtent — ils ne sont pas alternatifs :

IA ⊃ Machine Learning ⊃ Deep Learning ⊃ LLMs

Les LLMs sont un type spécifique de Deep Learning. Le Deep Learning est un sous-ensemble du Machine Learning. Et le Machine Learning est une des approches de l’IA. Quand tu choisis un LLM pour ton projet, tu choisis implicitement du Deep Learning, du Machine Learning, et de l’IA — mais l’inverse n’est pas vrai.

Analogie : C’est comme les véhicules. Voiture ⊂ Véhicule motorisé ⊂ Véhicule ⊂ Moyen de transport. Une voiture de sport est bien un moyen de transport, mais quand tu choisis un moyen de transport pour livrer 10 tonnes de marchandises, tu ne prends pas une voiture de sport. La hiérarchie existe, mais le choix dépend du cas d’usage.

Machine Learning — apprendre depuis des données

Le Machine Learning est la capacité d’un algorithme à s’améliorer automatiquement à partir d’exemples sans être explicitement programmé pour chaque cas. Au lieu de coder des règles manuellement, tu fournis des données et le modèle apprend les patterns tout seul.

Comment ça fonctionne

Le cycle fondamental du ML :

1. Tu fournis des données étiquetées — des exemples avec la réponse attendue (email + label “spam” ou “non-spam”)
2. L’algorithme apprend un modèle — il identifie les patterns qui distinguent spam et non-spam
3. Tu utilises le modèle pour prédire — sur de nouveaux emails jamais vus
4. Tu évalues et ré-entraînes — avec de nouvelles données pour améliorer la précision

Les algorithmes ML classiques incluent : régression linéaire, arbres de décision, Random Forest, SVM (Support Vector Machine), k-means pour le clustering, XGBoost. Tous ont en commun qu’ils travaillent sur des features numériques préparées manuellement.

ML en .NET avec ML.NET

Microsoft a intégré le Machine Learning directement dans l’écosystème .NET via ML.NET. Voici un exemple concret de classification binaire pour détecter des transactions frauduleuses :

// dotnet add package Microsoft.ML

using Microsoft.ML;
using Microsoft.ML.Data;

// 1. Définir les structures de données
public class Transaction
{
    [LoadColumn(0)] public float Amount { get; set; }
    [LoadColumn(1)] public float Hour { get; set; }
    [LoadColumn(2)] public float MerchantCategory { get; set; }
    [LoadColumn(3)] public float DistanceFromHome { get; set; }
    [LoadColumn(4)] public bool Label { get; set; } // true = fraude
}

public class FraudPrediction
{
    [ColumnName("PredictedLabel")]
    public bool IsFraud { get; set; }
    public float Probability { get; set; }
    public float Score { get; set; }
}

// 2. Entraîner le modèle
var context = new MLContext(seed: 42);

// Charger les données
var data = context.Data.LoadFromTextFile<Transaction>(
    "transactions.csv", hasHeader: true, separatorChar: ','
);

// Split train/test
var split = context.Data.TrainTestSplit(data, testFraction: 0.2);

// Pipeline : normalisation + algorithme
var pipeline = context.Transforms.NormalizeMinMax("Features",
    new[] { "Amount", "Hour", "MerchantCategory", "DistanceFromHome" })
    .Append(context.BinaryClassification.Trainers.FastTree(
        labelColumnName: "Label",
        featureColumnName: "Features",
        numberOfLeaves: 50,
        numberOfTrees: 100
    ));

// Entraînement
var model = pipeline.Fit(split.TrainSet);

// Évaluation
var predictions = model.Transform(split.TestSet);
var metrics = context.BinaryClassification.Evaluate(predictions, "Label");

Console.WriteLine($"Précision : {metrics.Accuracy:P2}");
Console.WriteLine($"AUC : {metrics.AreaUnderRocCurve:P2}");
Console.WriteLine($"F1 Score : {metrics.F1Score:P2}");

// 3. Utiliser le modèle en production
var predictor = context.Model.CreatePredictionEngine<Transaction, FraudPrediction>(model);

var transaction = new Transaction
{
    Amount = 1250.00f,
    Hour = 3,        // 3h du matin
    MerchantCategory = 7,
    DistanceFromHome = 450
};

var result = predictor.Predict(transaction);
Console.WriteLine($"Fraude : {result.IsFraud} (probabilité : {result.Probability:P1})");

Ce code fait quelque chose de remarquable : il entraîne un modèle de détection de fraude bancaire en moins de 50 lignes. Pas de mathématiques, pas de Python, pas de serveurs GPU — juste du C# standard dans ton projet .NET.

La limite cruciale du ML classique

Le ML classique excelle sur les données structurées (tableaux, CSV, bases de données). Mais il a une limite fondamentale : il a besoin de features préparées manuellement.

Pour détecter un chat sur une photo avec du ML classique, tu dois d’abord extraire manuellement : les bords, les textures, les couleurs dominantes, les formes géométriques, les proportions… Puis nourrir ces features numériques à l’algorithme. C’est fastidieux, subjectif, et souvent insuffisant pour des données complexes comme les images, le son, ou le texte brut.

Deep Learning — des réseaux de neurones profonds

Le Deep Learning résout exactement ce problème. Il utilise des réseaux de neurones artificiels avec de nombreuses couches cachées (d’où “deep”) qui apprennent automatiquement quelles features extraire — sans intervention humaine.

Le concept clé : feature learning automatique

Pour la même photo de chat, un réseau de neurones profond va apprendre en cascade :

• Couches 1-2 : détecter des bords et contrastes simples
• Couches 3-5 : assembler des formes (coins, courbes, cercles)
• Couches 6-10 : reconnaître des parties (oreilles, moustaches, museau)
• Dernières couches : classifier l’ensemble comme “chat” avec une probabilité

Tout ça automatiquement, sans que tu aies besoin de définir ce qu’est une “oreille de chat” ou une “moustache”. Le réseau l’apprend tout seul depuis des milliers d’exemples.

Les architectures majeures

Architecture	Spécialité	Exemples d’usage	Disponible via
CNN (Convolutional)	Images, vidéos	Reconnaissance d’images, OCR, détection d’objets	Azure Computer Vision
RNN/LSTM (Recurrent)	Séquences temporelles	Prévision de séries, audio, texte séquentiel	Azure Time Series
Transformer	Texte, séquences longues	LLMs, traduction, résumé, code	Azure OpenAI, Anthropic
Diffusion	Génération d’images	DALL-E, Stable Diffusion, Midjourney	Azure OpenAI (DALL-E)
GAN	Génération adversariale	Deepfakes, augmentation de données	Custom training

Deep Learning en .NET : ONNX et Azure

En tant que développeur .NET, tu n’as généralement pas à entraîner des modèles Deep Learning toi-même — c’est une discipline à part entière. Mais tu peux très facilement utiliser des modèles pré-entraînés via deux approches :

// Approche 1 : Azure Computer Vision (recommandée pour commencer)
// dotnet add package Azure.AI.Vision.ImageAnalysis

using Azure.AI.Vision.ImageAnalysis;

var client = new ImageAnalysisClient(
    new Uri(Environment.GetEnvironmentVariable("AZURE_VISION_ENDPOINT")!),
    new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_VISION_KEY")!)
);

var result = await client.AnalyzeAsync(
    ImageUrl: new Uri("https://example.com/invoice.jpg"),
    VisualFeatures: VisualFeatures.Read | VisualFeatures.Objects | VisualFeatures.Tags
);

// Texte extrait par OCR (Deep Learning CNN sous le capot)
foreach (var line in result.Value.Read.Blocks.SelectMany(b => b.Lines))
{
    Console.WriteLine(line.Text);
}

// Objets détectés dans l'image
foreach (var obj in result.Value.Objects.Values)
{
    Console.WriteLine($"{obj.Tags[0].Name} ({obj.Tags[0].Confidence:P0})");
}

// Approche 2 : ONNX Runtime (modèle local, sans cloud)
// dotnet add package Microsoft.ML.OnnxRuntime

using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;

// Charger un modèle ONNX exporté (ex: ResNet50 pour classification d'images)
using var session = new InferenceSession("resnet50.onnx");

// Préparer l'input (image préprocessée en tensor float32)
var inputTensor = new DenseTensor<float>(new[] { 1, 3, 224, 224 });
// ... remplir le tensor avec les pixels normalisés ...

var inputs = new List<NamedOnnxValue>
{
    NamedOnnxValue.CreateFromTensor("input", inputTensor)
};

using var outputs = session.Run(inputs);
var probabilities = outputs.First().AsEnumerable<float>().ToArray();
var topClassIndex = Array.IndexOf(probabilities, probabilities.Max());

Console.WriteLine($"Classe prédite : {topClassIndex} (probabilité : {probabilities[topClassIndex]:P1})");

Conseil pratique : Pour la grande majorité des cas d’usage en entreprise, préfère les services cognitifs Azure (Computer Vision, Speech, Form Recognizer) plutôt que d’entraîner tes propres modèles Deep Learning. L’entraînement de modèles custom nécessite des datasets massifs, des GPUs coûteux, et une expertise en Data Science. Les APIs cloud te donnent accès à des modèles entraînés sur des milliards d’exemples pour quelques centimes par requête.

LLMs — des Transformers entraînés à l’échelle

Les Large Language Models sont un type spécifique de Deep Learning basé sur l’architecture Transformer, introduite par Google en 2017 dans le papier révolutionnaire “Attention Is All You Need”.

Ce qui rend les LLMs différents

Trois caractéristiques distinguent les LLMs du Deep Learning classique :

1. Échelle massive — GPT-4 aurait environ 1 750 milliards de paramètres. BERT, un des premiers grands modèles Transformer, en avait 340 millions. L’ordre de grandeur change tout.
2. Entraînement auto-supervisé — les LLMs s’entraînent sur du texte brut sans labels humains. L’objectif : prédire le prochain token. Ça permet d’utiliser l’intégralité d’internet comme dataset.
3. Capacités émergentes — à partir d’une certaine taille, des capacités apparaissent spontanément que personne n’a explicitement entraînées : raisonnement, résolution de problèmes, génération de code, traduction entre langues jamais vues ensemble.

L’architecture Transformer en 2 minutes

Le mécanisme clé du Transformer est l’attention (ou “self-attention”). Pour chaque token dans une séquence, le modèle calcule à quel point chaque autre token est pertinent pour comprendre ce token.

Exemple : dans la phrase “La tour Eiffel est belle. Elle se trouve à Paris.”, pour comprendre que “Elle” désigne la tour Eiffel, le mécanisme d’attention calcule la relation entre “Elle” et tous les autres tokens — et apprend que “Elle” a une forte relation avec “tour Eiffel” dans ce contexte.

Ce mécanisme peut être parallélisé massivement sur GPU (contrairement aux RNN qui devaient traiter les séquences token par token), ce qui a permis d’entraîner des modèles beaucoup plus grands, beaucoup plus vite.

LLM en .NET — streaming en temps réel

// dotnet add package OpenAI

using OpenAI;
using OpenAI.Chat;

var client = new ChatClient(
    model: "gpt-4o",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")!
);

var messages = new List<ChatMessage>
{
    ChatMessage.CreateSystemMessage(
        "Tu es un expert .NET senior. Tes réponses sont précises, avec du code C# quand c'est pertinent."
    ),
    ChatMessage.CreateUserMessage(
        "Explique-moi la différence entre IEnumerable et IQueryable en Entity Framework Core."
    )
};

// Streaming — affiche les tokens au fur et à mesure
Console.Write("Réponse : ");
await foreach (var update in client.CompleteChatStreamingAsync(messages))
{
    foreach (var part in update.ContentUpdate)
    {
        Console.Write(part.Text);
    }
}
Console.WriteLine();

// Version non-streaming (attend la réponse complète)
var response = await client.CompleteChatAsync(messages);
string fullResponse = response.Value.Content[0].Text;

Le framework de décision : lequel choisir ?

Voici le framework que j’utilise pour choisir entre ML classique, Deep Learning, et LLMs :

Critère	ML Classique	Deep Learning	LLMs
Type de données	Structurées (tableaux)	Images, audio, vidéo, texte complexe	Texte, code, multimodal
Quantité de données	100 à 1M exemples	10K à 100M exemples	Pas besoin (modèle pré-entraîné)
Interprétabilité	Haute (arbres de décision)	Faible (boîte noire)	Faible, mais explicable en langage naturel
Coût	Faible (CPU suffit)	Élevé (GPU nécessaire)	Moyen (paiement à l’usage)
Temps de mise en prod	Jours à semaines	Semaines à mois	Heures à jours
Exemple .NET	ML.NET	Azure Cognitive Services, ONNX	Azure OpenAI, OpenAI SDK

Cas d’usage concrets pour un développeur .NET

Choisis ML.NET (ML classique) si :

• Tu veux prédire un nombre (prix, durée, quantité) depuis des données tabulaires
• Tu veux classer des clients ou transactions en catégories prédéfinies
• Tu veux détecter des anomalies dans des séries de métriques
• Tu veux faire du clustering sur des données métier
• La régulation ou l’auditabilité exige un modèle interprétable

Choisis Azure Cognitive Services / ONNX (Deep Learning) si :

• Tu dois analyser des images (OCR sur factures, détection de défauts produits)
• Tu dois traiter de l’audio (transcription, détection d’émotions vocales)
• Tu dois analyser des vidéos
• Tu as un cas d’usage très spécifique avec assez de données pour fine-tuner

Choisis un LLM (OpenAI, Claude, Azure OpenAI) si :

• Tu traites du texte non structuré (emails, avis clients, contrats, tickets)
• Tu génères du contenu (descriptions produits, résumés, rapports)
• Tu veux un chatbot ou assistant conversationnel
• Tu extrais des informations structurées depuis du texte (parsing de documents)
• Tu génères du code ou analyses du code existant
• Tu as besoin d’une réponse rapide sans entraînement custom

Règle d’or : Si ton problème implique du texte libre ou de la génération de contenu → LLM. Si ton problème implique des images ou de l’audio → Deep Learning via Azure. Si ton problème implique des données tabulaires et des prédictions numériques → ML.NET. En cas de doute, commence par un LLM : tu pourras toujours migrer vers une solution plus spécialisée si tu identifies des limitations précises.

Combinaison des approches — l’avenir est hybride

En production, les meilleurs systèmes combinent souvent plusieurs approches. Voici un exemple d’architecture hybride pour une app de traitement de factures :

1. Azure Computer Vision (Deep Learning CNN) → OCR pour extraire le texte de l’image de la facture
2. LLM GPT-4o (Transformer) → Parser le texte extrait pour identifier montant, date, fournisseur, lignes de facture dans un JSON structuré
3. ML.NET (ML classique) → Classifier la facture par catégorie comptable selon les patterns historiques de ta société
4. Règles métier classiques → Valider que le montant est dans les limites autorisées, que le fournisseur est dans la liste approuvée

Chaque couche fait ce qu’elle fait le mieux. Le LLM ne fait pas l’OCR (moins précis et plus cher que Computer Vision). ML.NET ne fait pas le parsing de texte (trop rigide). Computer Vision ne fait pas la classification comptable (pas assez de sémantique métier). C’est la combinaison qui crée un système robuste.

Exercice pratique

Pour ancrer ces concepts, fais cet exercice en deux parties :

Partie 1 — Classification : Pour chacun des cas d’usage suivants, identifie quelle technologie utiliser (ML classique / Deep Learning / LLM) et pourquoi :

1. Prédire le churn (désabonnement) des clients depuis leurs données d’utilisation
2. Générer des descriptions produits pour un catalogue e-commerce
3. Détecter des défauts sur des pièces industrielles depuis des photos
4. Analyser le sentiment des avis clients (positif / négatif / neutre)
5. Prévoir la consommation électrique d’un bâtiment pour les 24 prochaines heures
6. Extraire les clauses importantes d’un contrat juridique en PDF

Partie 2 — Implémentation : Crée une Console App .NET et implémente les deux exemples de code de cette leçon — le modèle ML.NET de détection de fraude (avec des données synthétiques) et l’appel LLM avec streaming. Observe les différences d’API, de latence, et de coût entre les deux approches.

Réponses partie 1 : 1) ML classique (données tabulaires, prédiction binaire) — 2) LLM (génération de texte) — 3) Deep Learning CNN (analyse d’images) — 4) LLM ou ML.NLP (texte, mais LLM plus flexible) — 5) ML classique ou LSTM (séries temporelles) — 6) LLM (document complexe, extraction sémantique)

Récapitulatif

• ML classique = données structurées, features manuelles, modèles interprétables → ML.NET
• Deep Learning = données non structurées (images, audio), features automatiques → Azure Cognitive Services, ONNX
• LLMs = texte, génération, conversation, extraction sémantique → Azure OpenAI, OpenAI SDK
• La hiérarchie : LLM ⊂ Deep Learning ⊂ ML ⊂ IA
• En production, combine les trois selon les forces de chacun
• En cas de doute pour un projet .NET → commence par un LLM

Dans la prochaine leçon, on ouvre le capot d’un LLM et on comprend en détail comment il prédit le prochain token — et pourquoi ce mécanisme explique à la fois ses capacités extraordinaires et ses limites parfois frustrantes.