Intelligence artificielle et Deep Learning — Introduction à l'Intelligence Artificielle (IA)

John Samuel, CPE Lyon · Année 2026-2027 · Courriel : john.samuel@cpe.fr

Enseignant-chercheur, Conception logicielle et Big Data. Recherche : représentation de connaissances, web sémantique, services web, intégration de données, entrepôts de données, systèmes distribués, SIG.

Ce cours est sous licence CC BY-SA 4.0.

Touches : ← → pour changer de diapositive, n pour les notes, r pour le mode lecture (toutes les diapositives et leurs notes).

Le projet constitue 100 % de l’évaluation du cours.

• Objectifs du cours : introduction à l'Intelligence Artificielle (IA), apprentissage machine, apprentissage profond, applications de l'IA.
• La figure reprend le schéma « position du deep learning » : l'apprentissage profond est un sous-ensemble de l'apprentissage machine, lui-même un sous-ensemble de l'intelligence artificielle.

• 1. Les fondements de l'IA : 1.1 Logique et raisonnement ; 1.2 Représentation des connaissances ; 1.3 Agents intelligents ; 1.4 Apprentissage machine ; 1.5 Apprentissage profond.

• Logique propositionnelle : système formel qui permet de représenter et d'évaluer des propositions en utilisant des connecteurs logiques (comme ET, OU, NON) pour déterminer leur vérité.
• Logique du premier ordre (logique des prédicats) : extension de la logique propositionnelle qui permet de représenter des propositions plus complexes en introduisant des variables, des constantes, des fonctions et des prédicats.
• Logique modale : extension de la logique qui permet de représenter des notions de possibilité, de nécessité, de croyance et d'autres modalités.
• Raisonnement automatisé : utilisation de systèmes informatiques pour effectuer des inférences logiques et déduire de nouvelles informations à partir de connaissances existantes.
• Problèmes de décision et résolution de problèmes : situations où une décision doit être prise parmi plusieurs options possibles, généralement sous contraintes. La résolution de problèmes implique la recherche d'une solution en utilisant des méthodes algorithmiques ou heuristiques pour atteindre un objectif spécifique.

• Raisonnement automatisé : utilisation de systèmes informatiques pour effectuer des inférences logiques et déduire de nouvelles informations à partir de connaissances existantes.
• Problèmes de décision et résolution de problèmes : situations où une décision doit être prise parmi plusieurs options possibles, généralement sous contraintes ; la résolution de problèmes cherche une solution par des méthodes algorithmiques ou heuristiques pour atteindre un objectif spécifique.

• Les propositions sont des déclarations qui peuvent être vraies (V) ou fausses (F). Avec deux propositions simples P, Q, les connecteurs logiques construisent des propositions plus complexes.
• NON (¬) : la négation inverse la valeur de vérité. Si P est vrai, NON P est faux, et inversement.
• ET (∧) : vrai seulement si toutes les propositions connectées sont vraies.
• OU (∨) : vrai si au moins l'une des propositions est vraie ; faux si les deux sont fausses.
• XOR (⊕) : vrai si une seule des propositions est vraie, mais pas les deux.
• Implication (⇒) : la vérité de la première proposition entraîne la vérité de la seconde. Si P est faux, P ⇒ Q est toujours vrai, car il ne dit rien sur Q.
• Équivalence (⇔) : deux propositions ont la même valeur de vérité dans toutes les situations.

• Les propositions dans la logique propositionnelle sont des déclarations qui peuvent être vraies (V) ou fausses (F). Supposons que nous ayons deux propositions simples : P, Q. Nous pouvons utiliser des connecteurs logiques pour créer des propositions plus complexes à partir de ces propositions simples.

• Supposons que nous ayons quatre propositions simples : P, Q, R et S. P : présence de l'eau. Q : présence de sable. R : présence d'oiseaux marins. S : présence de bateaux.
• Photos : Sea gull, Marseille et Sea Gull, Venice Beach, Wikimedia Commons.

• Avec ces propositions, nous pouvons définir des règles pour déterminer si une image représente la mer : si l'eau est présente (P), il est possible que l'image soit celle de la mer ; le sable (Q) renforce la probabilité d'une plage de mer ; des oiseaux marins (R) renforcent également la probabilité d'une scène liée à la mer ; des bateaux (S) suggèrent une forte probabilité de scène maritime.
• Nous pouvons utiliser des opérateurs logiques pour combiner ces propositions : Image de la mer : (P ET Q) OU (P ET R) OU (P ET S).

• from propositional_logic import *
  # définir les propositions
  P = Proposition("L'eau est présente")
  Q = Proposition("Il y a du sable")
  R = Proposition("Des oiseaux marins sont présents")
  S = Proposition("Des bateaux sont visibles")
  # définir les propositions composées
  rule1 = And(P, Q)
  rule2 = And(P, R)
  rule3 = And(P, S)
  # définir la proposition principale
  image_de_la_mer = Or(Or(rule1, rule2), rule3)
  # évaluer des propositions
  P.value = True
  Q.value = True
  R.value = False
  S.value = False
  print(image_de_la_mer.evaluate()) # Sortie: True

• Ville : A immeubles, B voitures, C piétons, D feux de circulation ; ville = Or(Or(And(A, B), And(A, C)), And(A, D)). Avec A et B vrais, C et D faux, ville.evaluate() renvoie True.

• from propositional_logic import *
  # Définir les propositions
  A = Proposition("L'utilisateur aime l'image actuelle")
  B = Proposition("L'image actuelle est un portrait")
  C = Proposition("L'image actuelle est une œuvre abstraite")
  D = Proposition("L'utilisateur a aimé une œuvre similaire par le passé")
  E = Proposition("L'image est en noir et blanc")
  F = Proposition("L'image est en couleur")
  G = Proposition("L'utilisateur préfère les œuvres d'art réalistes")
  H = Proposition("L'image est une peinture réaliste")
  I = Proposition("L'utilisateur a aimé les œuvres de cet artiste dans le passé")
  J = Proposition("L'utilisateur n'aime pas les images très saturées")
  K = Proposition("L'image a une saturation élevée")

• Règle 2 : Implication(Xor(B, C), Not(G)) — avec B vrai, C faux, G vrai, l'évaluation renvoie False (la prémisse B ⊕ C est vraie mais la conclusion ¬G est fausse).
• Règle 6 : Implication(Or(G, D), Not(C)) — avec G vrai, D faux, C faux, l'évaluation renvoie True.
• La logique propositionnelle ne parle que de faits entiers ; pour dire « toutes les mers sont salées » il faut des variables : la logique du premier ordre.

• Contrairement à la logique propositionnelle, qui traite uniquement de la vérité ou de la fausseté de propositions simples, la logique du premier ordre permet de représenter des informations structurées sur des objets et leurs relations. Voici quelques concepts clés de la logique du premier ordre : variables, constantes, fonctions, prédicats, quantificateurs, opérateurs logiques.

• Un objet x (une image), des prédicats vrais ou faux pour chaque x, une règle qui en déduit EstMer(x) ; ∀x pour toute image, ∃x il existe au moins une image.

• Exemple — Variables : « x » peut représenter n'importe quelle mer. Constantes : « Mer Méditerranée », « Mer Noire », « Mer Rouge ». Fonctions : « Profondeur(x) » représente la profondeur de la mer x ; « Profondeur(Mer Méditerranée) » renvoie la profondeur de la mer Méditerranée.
• Prédicats : « Salée(x) » indique si une mer donnée est salée ; « Salée(Mer Méditerranée) » est vrai. Quantificateurs : « ∀x Salée(x) » — toutes les mers sont salées ; « ∃x Superficie(x) > 100 000 km² » — il existe une mer dont la superficie dépasse 100 000 km².
• Les fonctions attribuent des valeurs à des objets ou effectuent des opérations ; les prédicats expriment des relations ou des propriétés et renvoient une valeur booléenne.

• Utilisons l'exemple des règles pour confirmer qu'une image représente effectivement une mer. Constantes : noms d'images spécifiques ou identifiants uniques. Variable : « x » pour une image générique. Prédicats : ContientEau(x), ContientSable(x), ContientBateaux(x), ContientOiseauxMarins(x). Quantificateurs : « ∃x » (il existe une image) ou « ∀x » (pour toutes les images).

• Reprenons l'exemple des règles pour confirmer qu'une image représente une mer. Constantes : noms d'images spécifiques ou identifiants uniques. Variables : « x » pour une image générique.
• Prédicats : ContientEau(x), ContientSable(x), ContientBateaux(x), ContientOiseauxMarins(x) indiquent si l'image x contient de l'eau, du sable, des bateaux, des oiseaux marins.
• Quantificateurs : « ∃x » (il existe une image) ou « ∀x » (pour toutes les images) spécifient la portée des règles.
• Règles : 1. ∀x (ContientEau(x) ∧ ContientSable(x) ⇒ EstMer(x)) ; 2. ∀x (ContientBateaux(x) ⇒ EstPort(x)), ∀x (ContientOiseauxMarins(x) ⇒ EstPlage(x)) ; 3. ∃x (ContientEau(x) ∧ ContientSable(x)).

• Z3 est un puissant solveur de contraintes développé par Microsoft Research, souvent utilisé pour la vérification formelle, le raisonnement logique et d'autres tâches d'analyse symbolique. Il peut résoudre des équations et des inégalités, vérifier la satisfiabilité de formules logiques, et bien plus encore.
• Installation : pip install z3-solver. Importation : from z3 import *.
• Fonctions utiles : solver.check() vérifie si les contraintes sont satisfiables ; solver.model() retourne une solution possible ; solver.add(constraint) ajoute une ou plusieurs contraintes.
• Une fois les bases acquises, on peut explorer la quantification, les domaines spécifiques (bit-vectors, arrays) et la programmation modulaire.

• Importation : from z3 import *. Pour créer des variables symboliques, vous utilisez les fonctions de Z3 comme Int(), Real(), Bool(), etc. Cela crée deux variables entières x et y.
• Vous pouvez maintenant formuler des contraintes logiques ou des équations en utilisant ces variables : constraint1 = x + y > 5, constraint2 = x - y < 3.

• Z3 utilise un solveur pour vérifier si ces contraintes peuvent être satisfaites : solver = Solver(); solver.add(constraint1); solver.add(constraint2).
• Si le solveur retourne sat, cela signifie qu'il existe une solution qui satisfait les contraintes, et vous pouvez afficher le modèle de solution avec solver.model().

• Quelques fonctions utiles : solver.check() vérifie si les contraintes sont satisfiables ; solver.model() retourne une solution possible si les contraintes sont satisfiables ; solver.add(constraint) ajoute une ou plusieurs contraintes au solveur.
• Z3 est un outil très puissant pour résoudre des problèmes de logique et d'optimisation. Il est utilisé dans des domaines tels que la vérification de logiciels, la planification, et le raisonnement automatique. Une fois que vous vous familiarisez avec les bases, vous pouvez explorer des fonctionnalités plus avancées comme la quantification, les domaines spécifiques (bit-vectors, arrays), et la programmation modulaire.

• Sorts (types) — types de base : Int, Real, Bool, String, etc. ; sorts définis par l'utilisateur : en plus de DeclareSort, on crée des types complexes en combinant types de base et sorts définis.
• Expressions — booléennes : And, Or, Not, Implies ; arithmétiques : +, -, *, / sur entiers et réels.

• Quantificateurs — universels (ForAll) : propriétés vraies pour tous les éléments d'un type ; existentiels (Exists) : il existe au moins un élément qui satisfait la propriété.
• Solver — instanciation et vérification : le Solver ajoute des contraintes et vérifie leur satisfaisabilité avec check() ; modèles : model() montre l'assignation des constantes et variables.
• Assertions — add() introduit des contraintes : expressions booléennes ou équations.

• DeclareSort : déclare un nouveau type (ou sorte) dans le système de types de Z3, pour des objets qui ne correspondent pas aux types de base comme Int, Bool. Image = DeclareSort('Image') : Image est une nouvelle sorte qui peut représenter des images dans le modèle.
• Const : déclare des constantes d'un type spécifique, c'est-à-dire une instance d'un objet de la sorte définie. x = Const('x', Image) : x est une constante de type Image, une image particulière dans vos formules.
• Function : déclare des fonctions qui prennent des arguments et renvoient des valeurs, pour exprimer des relations entre objets. ContientEau = Function('ContientEau', Image, BoolSort()) : ContientEau prend une constante de type Image et renvoie un booléen — utilisable pour vérifier si une image contient de l'eau.

• Code du cours original : création du solveur, de la sorte Image, des fonctions ContientEau, ContientSable, ContientBateaux, ContientOiseauxMarins (contenu d'une image) et des relations EstMer, EstPort, EstPlage (types d'images).

• from z3 import *
  # Créer un solver
  solver = Solver()
  # Définir une sorte pour les images
  Image = DeclareSort('Image')
  # Définir des fonctions pour vérifier le contenu d'une image
  ContientEau = Function('ContientEau', Image, BoolSort())
  ContientSable = Function('ContientSable', Image, BoolSort())
  ContientBateaux = Function('ContientBateaux', Image, BoolSort())
  ContientOiseauxMarins = Function('ContientOiseauxMarins', Image, BoolSort())
  # Définir des relations pour les types d'images
  EstMer = Function('EstMer', Image, BoolSort())
  EstPort = Function('EstPort', Image, BoolSort())
  EstPlage = Function('EstPlage', Image, BoolSort())
  
  # Règles
  # 1. Si une image contient de l'eau et du sable, alors c'est une mer
  x = Const('x', Image)
  solver.add(Implies(And(ContientEau(x), ContientSable(x)), EstMer(x)))
  # 2. Si une image contient des bateaux, alors c'est un port
  solver.add(Implies(ContientBateaux(x), EstPort(x)))
  # 3. Si une image contient des oiseaux marins, alors c'est une plage
  solver.add(Implies(ContientOiseauxMarins(x), EstPlage(x)))
  # 4. Il existe au moins une image qui contient de l'eau et du sable
  solver.add(Exists([x], And(ContientEau(x), ContientSable(x))))

• Dans le cours original, la variable x est déclarée avec Const et les règles sont ajoutées sans ForAll explicite : x est alors une constante libre. Pour une règle vraiment universelle, envelopper l'implication dans ForAll([x], …).

• # Exemple d'images à vérifier
  img1 = Const('img1', Image)
  img2 = Const('img2', Image)
  # Définir des contenus pour img1 et img2
  solver.add(ContientEau(img1) == True)
  solver.add(ContientSable(img1) == True)
  solver.add(ContientBateaux(img1) == False)
  solver.add(ContientOiseauxMarins(img1) == False)
  
  # Vérifier si les images respectent les règles
  if solver.check() == sat:
      print("Les images respectent les règles définies.")
  else:
      print("Les images ne respectent pas les règles définies.")
  # Afficher les modèles (si satisfaisables)
  print(solver.model())

• Un solveur comme Z3 ne « raisonne » pas comme nous : il cherche un modèle qui satisfait toutes les contraintes, ou prouve qu'il n'en existe pas. Le modèle réel affiché par Z3 utilise des valeurs internes (Image!val!0…) et des interprétations de fonctions ; le tableau en donne une lecture simplifiée.

• La logique modale est une extension de la logique classique qui permet de raisonner sur la notion de « modalités », c'est-à-dire des catégories de propositions qui expriment des modalités ou des qualités spécifiques, telles que la nécessité, la possibilité, l'obligation, la croyance, etc.
• Opérateurs modaux : les deux opérateurs les plus courants sont ◻ (carré), qui exprime la nécessité, et ◇ (losange), qui exprime la possibilité.

• En logique modale, les termes « nécessaire », « contingent », « possible » et « impossible » décrivent les modalités d'une proposition.
• Nécessaire : vraie dans toutes les situations possibles ; ◻(P). Contingent : vraie dans certaines situations possibles et fausse dans d'autres ; ni nécessairement vraie ni nécessairement fausse (¬□P ∧ ¬□¬P). Possible : vraie dans au moins une situation possible ; ◇(Q). Impossible : fausse dans toutes les situations possibles ; ¬◇(R).
• Exemples : ◻(Toute mer est salée) — dans toutes les situations possibles, toutes les mers sont salées. (Il peut y avoir des mers calmes) — possible, mais pas nécessairement dans toutes les situations. ◇(Il est possible qu'il y ait des tempêtes en mer). ¬◇(Toutes les mers sont douces) — impossible.

• Le raisonnement automatisé est un domaine de l'intelligence artificielle (IA) qui concerne la création de systèmes informatiques capables de tirer des conclusions logiques et de résoudre des problèmes de manière autonome, similaire à la manière dont les humains utilisent leur raisonnement pour résoudre des problèmes.

• Le raisonnement automatisé peut être expliqué en utilisant différentes logiques : propositionnelle, du premier ordre et modale.
• En logique propositionnelle : connaissances représentées sous forme de propositions atomiques et de règles logiques ; le moteur applique des règles logiques pour tirer des conclusions.
• En logique du premier ordre : représentation plus expressive, relations complexes entre objets et généralisations ; règles de déduction plus sophistiquées, avec ∀ et ∃.
• En logique modale : opérateurs modaux pour l'incertitude et la nécessité ; règles modales spécifiques.

• La représentation des connaissances joue un rôle central dans la manière dont les systèmes informatiques comprennent, raisonnent et interagissent avec le monde.
• Elle désigne le processus de capture, de structuration et de stockage des informations et des connaissances de manière à les rendre utilisables par des systèmes informatiques : transformer des données brutes ou des concepts en une forme que les ordinateurs peuvent comprendre et exploiter pour résoudre des problèmes, prendre des décisions ou interagir avec les utilisateurs.
• Résolution de problèmes : une représentation adéquate permet de modéliser des problèmes complexes et de les résoudre efficacement ; elle facilite la manipulation et la déduction logique des informations pertinentes.
• Prise de décisions : les machines doivent comprendre le monde qui les entoure pour interagir avec lui de manière significative — objets, relations, événements, règles.
• Communication homme-machine : une représentation claire et conviviale est essentielle pour rendre les interactions compréhensibles et productives.

• Les types de connaissances peuvent être classés en plusieurs catégories : déclaratives, procédurales, explicites et tacites.
• Connaissances déclaratives : « ce que nous savons » — faits, informations et déclarations qui décrivent le monde, souvent exprimés sous forme de propositions vraies ou fausses.
• Connaissances procédurales : « comment faire quelque chose » — compétences, savoir-faire et procédures nécessaires pour accomplir des tâches ; généralement implicites et liées à l'expérience pratique.
• Connaissances explicites : clairement exprimées et documentées ; formelles et structurées pour être transmises et partagées facilement — manuels, livres, bases de données.
• Connaissances tacites : difficiles à exprimer verbalement ou à documenter ; elles résident souvent dans l'expérience personnelle, l'intuition ou les compétences pratiques ; elles sont difficiles à transférer d'une personne à une autre et sont souvent acquises par l'expérience.

• Dans la représentation des connaissances déclaratives, les faits, les informations et les connaissances sont exprimés sous forme de propositions logiques : logique propositionnelle, logique du premier ordre.
• Graphes de connaissances (ontologies) : structures de données hiérarchiques qui organisent les connaissances en utilisant des concepts, des classes, des propriétés et des relations.
• Concepts : entités ou idées du monde réel. Classes : les concepts sont souvent organisés en classes. Propriétés : les ontologies spécifient des propriétés et des relations entre les concepts. Relations : les ontologies capturent les relations entre les concepts.

• Les agents intelligents sont des entités logicielles ou matérielles capables de percevoir leur environnement, de prendre des décisions, et d'agir pour atteindre des objectifs spécifiques. Un agent intelligent est un système informatique ou une entité physique qui possède certaines caractéristiques clés : perception, raisonnement, action, objectifs.

• Un agent perçoit son environnement, raisonne et agit ; ses actions modifient l'environnement, qui est perçu à nouveau. Objectifs et mémoire (modèle du monde) sont optionnels selon le type d'agent.

• Agents réactifs simples : réagissent directement aux stimuli de leur environnement sans représentation interne complexe du monde. Décisions fondées sur des règles préétablies qui associent des entrées (perceptions) à des sorties (actions). Utilisés là où la réactivité immédiate est cruciale (robotique industrielle) ; ils manquent de capacité à anticiper ou à planifier à long terme.
• Agents basés sur des modèles : représentation interne du monde (modèles, cartes conceptuelles) pour anticiper les conséquences de leurs actions, planifier des séquences d'actions et décider. Planification automatisée, simulation, modélisation de systèmes complexes. Plus flexibles, mais leur performance dépend de la qualité de leurs modèles.
• Agents basés sur les buts : objectifs à atteindre ; ils évaluent l'état de l'environnement et déterminent les actions qui les en rapprochent, en planifiant et en ajustant. Planification de parcours, systèmes de recommandation, assistants personnels.
• Agents hybrides : combinent plusieurs types — réactifs dans l'immédiat, à modèle ou à buts pour les tâches complexes ou à long terme ; plus polyvalents.
• Agents fondés sur un modèle de langage (agents LLM) : depuis 2023, un grand modèle de langage (voir 4.7) placé dans une boucle perception-raisonnement-action : il lit l'état de l'environnement (texte, résultats d'outils), planifie en langage naturel et agit en appelant des outils (recherche, code, API). Même schéma, avec le modèle de langage comme moteur de raisonnement.

• Agents réactifs simples : règles préétablies perception → action, pas de représentation interne complexe ; robotique industrielle ; pas d'anticipation ni de planification à long terme.
• Agents basés sur des modèles : représentation interne du monde (modèles, cartes conceptuelles) ; anticipent, planifient, décident ; planification automatisée, simulation, modélisation de systèmes complexes ; performance dépendante de la qualité du modèle.

• Agents basés sur les buts : objectifs à atteindre, évaluation régulière de l'état, planification et ajustement ; parcours, recommandation, assistance personnelle.
• Agents hybrides : réactifs dans l'immédiat, à modèle ou à buts pour le long terme ; plus polyvalents.
• Agents LLM : depuis 2023, un grand modèle de langage dans la boucle perception-raisonnement-action ; lit l'état, planifie en langage naturel, appelle des outils.

• Apprentissage supervisé : un modèle est formé à partir d'un ensemble de données étiquetées — chaque exemple est associé à une étiquette ou une catégorie connue. L'objectif est d'apprendre à faire des prédictions en généralisant à de nouvelles données non vues. Exemples : classification d'images, prédiction de prix, détection de spam.
• Apprentissage non supervisé : pas de données étiquetées ; le modèle doit découvrir des structures, des motifs ou des regroupements par lui-même. Exemples : segmentation de clients, réduction de la dimensionnalité, détection d'anomalies.
• Apprentissage semi-supervisé : un petit ensemble étiqueté et une grande quantité de données non étiquetées ; le modèle apprend sur les étiquettes et tire parti des données brutes pour améliorer sa performance. Utile lorsque l'étiquetage est coûteux ou difficile.

• Apprentissage supervisé : modèle formé sur des données étiquetées ; objectif : généraliser à de nouvelles données. Exemples : classification d'images, prédiction de prix, détection de spam.
• Apprentissage non supervisé : pas de données labellisées ; découvrir des structures, des modèles ou des regroupements. Exemples : segmentation de clients, réduction de dimensionnalité, détection d'anomalies.
• Apprentissage semi-supervisé : petit ensemble étiqueté et grande quantité non étiquetée ; utile lorsque l'étiquetage est coûteux ou difficile.

• Dans l'apprentissage profond, le terme « profond » fait référence à la présence de multiples couches dans le réseau neuronal. Contrairement aux modèles plus simples, tels que les perceptrons monocouche, les réseaux profonds ont la capacité d'apprendre des représentations hiérarchiques complexes à partir de données brutes.
• Perceptron linéaire et XOR : un perceptron linéaire simple ne peut pas être un classificateur universel ; il est incapable de résoudre des problèmes non linéaires comme XOR. En ajoutant des couches et des non-linéarités (fonctions d'activation), on construit des réseaux capables de résoudre des problèmes plus complexes.

• Extraction progressive de caractéristiques : une caractéristique clé de l'apprentissage profond est la capacité à extraire progressivement des caractéristiques complexes à partir de données brutes. Chaque couche du réseau apprend des représentations de plus en plus abstraites, ce qui permet au modèle de comprendre des niveaux de complexité croissants dans les données.
• Le fil rouge se referme : le prédicat que nous avons écrit à la main en logique du premier ordre est ce qu'un réseau profond apprend à partir de photos étiquetées (cours 3, réseaux convolutionnels).

• Références du cours original, conservées telles quelles ; les liens Z3 ont été ajoutés en 2026.

• Couleurs : Color Tool - Material Design. Images : Wikimedia Commons.