Dan Garlasu, dgarlasu@yahoo.

com

1
Ordre du jour
1 Objectifs (Goals)
1.1 Objectif vérificateur (Verifier Goal)
1.2 Objectifs du chercheur (Finder Goal)
1.3 Objectifs d’action (Doer Goal)
2 Quelques problèmes de mise en œuvre
2.1 L'algorithme de résolution par chaînage arrière (backtracking)
2.2 L'algorithme de résolution directe (forward resolution)
2.3 Débat

2
 Le terme "programmes en exécution" dans la programmation
logique fait généralement référence à la vérification:
◦ d'un ensemble de prédicats par rapport à
◦ un ensemble donné de règles d'inférence et de faits de base.
 Cette vérification se fait selon un algorithme spécifique qui sera
présenté dans ce cours. Le terme mécanisme de résolution est
souvent utilisé pour désigner cet algorithme.
 Ainsi, un calcul en programmation logique est identifié par les
composants suivants :
1. Une base de données des faits de base
2. Un ensemble de règles d'inférence
3. un objectif donné (requête)

3
 Un calcul en programmation logique est initié par un but
◦ Example:
 Base de données des faits de base
locVO(Subject, Day, Room): EnrollVO(Student, Subject):
locVO Subject Day Room enrollVO Student Subject
Hypermedia Monday Room 22 Palina Hypermedia
Palina Programming
Databases Tuesday Room 23 Alex Programming
Programming Thursday Room 22 Alex Databases

 Règles d'inférence:
mustGo(Student, Room, Day) :- $ Subject (enrollVO(Student, Subject) & locVO(Subject, Day, Room))
 Objectif (requête): ? mustGo(‘Alex’, ’Room 22’, ‘Thursday’)
Le résultat sera un succès ou un échec, selon que la validité de ce prédicat
(fait) a pu être vérifiée ou non.
Dans ce cas particulier, le calcul produira une valeur Vraie comme résultat.

4
 Dans un cas général, il faut distinguer trois types d'objectifs différents:
◦ Objectif vérificateur (Verifier Goal) parent G D
Nick Pauline
◦ Objectifs de recherche (Finder Goal) Pauline Alex
◦ Objectifs d’action (Doer Goal) Pauline Paul
Alex Tom

 Un objectif vérificateur est un prédicat sans variables libres, c'est-à-dire c'est un fait qui peut être Vrai
ou Faux selon un ensemble donné de faits de base, et de règles d'inférence.
 Par exemple, étant donné que nous avons des faits et des règles décrivant un arbre généalogique,
descendent(G,D):-parent(G,D)
descendent(G,D):- $ X (parent(G,X) & descendent(X,D))
 nous pourrions émettre l'objectif vérificateur suivant: ? descendent(‘Nick’,’Tom’)
◦ Cet objectif vérificateur peut être paraphrasé comme "Est-ce que Tom est un descendant de Nick ?" Dans ce cas, le moteur
renverrait simplement Oui ou Non selon les prédicats du programme.
 Un autre objectif vérificateur peut ressembler à ceci: ? $ X (parent(X,’Alex’) & parent(X,’Paul’))
◦ Le deuxième objectif vérificateur correspond à la question "Alex et Paul sont-ils frères ?". La dernière requête est
un peu plus compliquée. Elle est composée d'une conjonction de deux objectifs qui tentent essentiellement de
vérifier ce qui suit : «Y a-t-il une seule personne (X) qui est parent d'Alex et parent de Paul ?».
Note: on utilise ici des variables pour définir un objectif de vérificateur, qui sont liée au quantificateur existentiel.

5
  Bien sûr, les objectifs sont interprétés dans un certain environnement.
Considérez, par exemple, les faits et les règles décrivant une nomenclature,
need+(P,C,Q):-need(P,C,Q)
need+( P,C,(Q1*Q2)):- $ X (need(P,X,Q1) & need+(X,C,Q2))

 Dans cet environnement, nous pourrions émettre les objectifs vérificateurs

suivants:
? $ X (need+(‘D_A’,’D_E’,X)
 Cet objectif de vérificateur peut être paraphrasé comme "A-t-on besoin d'un
composant" D_E "pour assembler" D_A "?".

? $ X $ Y (need+(Y,’D_E’,X) & greaterThan(X,100))

 "Existe-t-il des composants où le composant 'D_E' est réutilisé en quantité
supérieure à 100 ?" need P C Q
D_A D_B 5
D_B D_D 3
D_B D_C 8
D_D D_E 4

Reponse: Faux (4 x 3 x 5 = 60 < 100)

6
 Dans les cas où un objectif contient des variables non liées, un tel objectif est appelé un
objectif de recherche. Un objectif de recherche demande à la logique du programme de
montrer des valeurs particulières de variables libres qui satisfaisont cet objectif. Pour clarifier
ce dernier point, considérons quelques exemples de requêtes.
 Exemple "Inscription des étudiants"
 Faits basiques :
enrollVO(Student, Subject)
locVO(Subject, Day, Room))
Règles d'inférence:
mustGo(Student, Room, Day) :- $ Subject (enrollVO(Student, Subject) & locVO(Subject, Day, Room))
Objectif de recherche:
? mustGo (‘Alex’,X,’Thursday’)
Le moteur va afficher toutes les valeurs valides pour le predicate mustGo(‘Alex’,X,’Thursday’): X = {Room 22}
? mustGo (‘Alex’,X,Y)
Le moteur va afficher tous les couples de valeurs (X, Y) tels que le prédicat mustGo (‘Alex’,X,Y) est valide:
{<X,Y>} = {<Room 23, Tuesday>,<Room 22, Thursday>}

7
Example “arbre généalogique”
 descendent(G,D):-parent(G,D)
 descendent(G,D):- $ X (parent(G,X) & descendent(X,D))
 Objectif de recherche: ? descendent(‘Nick’,X)
◦ Dans ce cas, le moteur affichera toutes les valeurs de la variable X qui satisfont le predicate
descendant (‘Nick’,X), c’est a dire: X = {Pauline,Alex,Paul,Tom}
 ? $ X (parent(X, ‘Alex’) & parent(X, Y))
◦ Cet objectif peut être paraphrasé comme «Obtenir tous les frères et sœurs d'une personne
‘Alex’». Ceci est intéressant à noter, malgré le fait que nous utilisons deux variables pour définir
l'objectif - X et Y, le système est invité à afficher uniquement les valeurs pour la variable Y qui
satisfont le predicate $ X (parent(X, ‘Alex’) & parent(X, Y)). La variable X est liée au quantificateur
existentiel et nous ne nous soucions pas de savoir quelle valeur particulière de la variable X
satisfait les conditions parent(X, ‘Alex’) & parent(X, Y)
parent G D
Nick Pauline
Pauline Alex
Pauline Paul
Alex Tom

8
 Exemple de "nomenclature" (bill of materials)
need+(P,C,Q):-need(P,C,Q)
need+( P,C,(Q1*Q2)):- $ X (need(P,X,Q1) & need+(X,C,Q2))
 Objectif de recherche:
? need+(‘D_B’,X, Y)
Actuellement, nous demandons aux systèmes d'afficher une liste des
matériaux nécessaires pour produire un composant « D_B » et de fournir
des informations supplémentaires sur la quantité de matériaux.
<X,Y> = {<D_D, 3>, <D_C, 8>, <D_E, 12>}

need P C Q
D_A D_B 5
D_B D_D 3
D_B D_C 8
D_D D_E 4

9
 Un autre type d'objectifs dans la programmation logique s'appelle un
objectif d'action. Comme leur nom l'indique, ces déclarations sont
utilisées pour communiquer des informations spécifiques afin de
modifier l'environnement pour d'autres objectifs.
 Dans le cas le plus simple, un objectif d’action ajoute/supprime
simplement des faits de base. Des cas plus complexes d'application
des objectifs d’action seront discutés ci-dessous

10
 Exemple "Inscription des étudiants"
enrollVO Student Subject
 Faits de base: enrollVO(Student, Subject) Palina Hypermedia
Palina Programming
Alex Programming
Alex Databases
locVO Subject Day Room

locVO(Subject, Day, Room)) Hypermedia Monday Room 22

Databases Tuesday Room 23
Programming Thursday Room 22

? delete(locVO(‘Programming’, ‘Thursday’, ‘Room 22’))

? add(locVO(‘Software Paradigms’, ‘Thursday’, ‘Room 21’))

locVO Subject Day Room ? add(enrollVO(‘Alex’, ‘Software Paradigms’))

Hypermedia Monday Room 22 ? delete(enrollVO(‘Alex’, ‘Programming’))
Databases Tuesday Room 23 ? add(enrollVO(‘Palina’, ‘Software Paradigms’))
Software Thursday Room 21 enrollVO Student Subject
Paradigms Palina Hypermedia
Palina Programming
Alex Databases
Alex Software Paradigms
Palina Software Paradigms

11
 Comment un SGBD déductif, infère-t-il une réponse à un objectif donné ?
 Etant donné un programme et une requête initiale, l'algorithme de
résolution pour vérifier cette requête peut être décrit comme suit.
◦ Phase 1: Un objectif donné est réduit à de sous-objectifs simples, correspondant à
des faits ou procédures élémentaires. Le processus est répété jusqu'à ce que le but
soit représenté sous la forme d'un arbre n'ayant que des sous-objectifs simples
correspondant à des faits ou des procédures de base, comme feuilles de l’arbre. Un
tel arbre est appelé arbre d'inférence ou arbre de résolution (voir exemple ci-
dessous).
◦ Phase 2 : On recherche de valeurs pour (vérifier) les sous-objectifs simples et les
assembler afin de former la réponse. Ce processus est en fait appelé chaînage
arrière ou parcours en arrière (backtraking).

12
 Example: Phase 1: Le système a construit un arbre de résolution
qui, dans ce cas particulier, ressemble à un processus en
Faits de base: deux étapes :
B1(x) Database:{2, 3, 4} • Étape 1.1 :
B21(x) Database:{1, 2, 3}
B22(x) Database:{1, 3, 9}
B3(x) Database:{1, 2, 5, 36}
Règles d'inférence:
P1(x) := B1(x) | P2 (x) & B3(x)
• Étape 1.2:
P2(x) := B21(x) & B22(x)
Objectif vérificateur: ? P1(1)

13
 Phase 2: Le système évalue des sous-objectifs simples et propage les valeurs de
manière ascendante (parcours en arrière). Dans ce cas particulier, cela ressemble
également à un processus en deux étapes :
◦ Étape 2.1 :

◦ Étape 2.2:

14
Les objectifs de recherche sont interprétés de la même manière.
Considérez l'objectif de recherche: ? P1(X)
 Phase 1: Le système a construit l’arbre de résolution suivant:

 Phase 2: Un terme particulièr est utilisé pour sélectionner un certain

nombre de faits de base qui définissent toutes les valeurs potentiellement
possibles des variables libres. Ces valeurs sélectionnées sont appelées
des hypothèses.

15
 Phase 3: Toutes les hypothèses sont vérifiées en tant que
objectives vérificateurs pour sélectionner des valeurs valides
de variables libres

 Toutes les hypothèses qui se sont avérées valides sont

considérées comme un résultat de l'objectif de recherche.

16
 La contrepartie de la procédure de chaînage arrière (backtracking) est
appelée procédure de chaînage avant ou en amonte (forward resolution).
 La procédure de chaînage avant consiste à rassembler les faits de base
pour en déduire tous les nouveaux faits possibles.
Example:
Faits de base:
B11(x) Database:{1, 2, 3, 4}
B12(x) Database:{3, 4, 5, 6}
B21(x) Database:{1, 2, 3, 4}
B22(x) Database:{1, 2, 3, 5}
Règles d'inférence:
P(x) := P1(x) | P2(x)
P1(x) := B11(x) &B12(x)
P2(x) := B21(x) & B22(x)

17
Étape 1: Le système déduit tous les faits P1;
Étape 3: Le système déduit tous les faits P;
Étape 2: Le système déduit tous les faits P2;
Remarque: la procédure de chaînage en arrière doit être invoquée
chaque fois que l'utilisateur émet un objectif de vérification ou de
recherche. La réponse est déduite dynamiquement et AUCUNE donnée
déduite n'est stockée dans la base de données. Au contraire, la
procédure de chaînage en avant doit être invoquée uniquement lorsque
la base de données est modifiée (c'est-à-dire lorsque l'utilisateur émet
un objectif d’action). Tous les faits définis au moyen de règles
d'inférence sont déduits et stockés dans la base de données. Ainsi, les
prochains objectifs de vérification ou de recherche peuvent être
interprétés au moyen de la recherche de tels faits inférés,
précédemment stockés.
Étant donné que l'interprétation d'un objectif de recherche peut prendre
un temps considérable, la procédure de chaînage arrière est
normalement appliquée pour les systèmes de base de données qui ne
sont pas critiques pour le temps de réponse. Les systèmes déductifs qui
sont censés de contrôler les processus en temps réel (par exemple, un
processus de raffinerie de pétrole), prennent normalement en charge la
procédure de chaînage avant pour minimiser un temps de réponse.
18
  Nous pouvons considérer la tâche d'exécution d'un programme logique comme un problème
de recherche. La représentation des objectifs en termes d'arbre et l'algorithme lui-même
supportent cette analogie.
◦ Par conséquent, l'objectif de l'algorithme est de trouver une solution s'il en existe une dans l'espace
de recherche. La nature de l’immersion d'abord (depth-first), et le chaînage arrière de l'algorithme
introduit, sont dans ce contexte simplement des fonctionnalités de calcul, pour faire face au non-
déterminisme de la tâche à accomplir. En théorie, tout autre moyen (correct) de traiter un tel non-
déterminisme pourrait être utilisé. Par exemple, la recherche de l'arborescence pourrait être
effectuée en largeur d'abord (breadth-first). Étant donné que les prédicats peuvent être récursifs, la
recherche en largeur aurait l'avantage de toujours trouver une solution chaque fois qu'elle existe.
D'autre part, une recherche en profondeur (depth-first) du même arbre peut ne pas se terminer,
lorsque par exemple des clauses récursives sont tentées en premier instance.

La recherche en largeur d'abord (BFS) est un algorithme permettant de parcourir

ou de rechercher des structures de données arborescentes ou graphiques. Il
commence à la racine de l'arbre (ou à un nœud arbitraire d'un graphe, parfois
appelé "clé de recherche") et explore d'abord les nœuds voisins, avant de passer
aux voisins de niveau supérieur.
BFS a été inventé à la fin des années 1950 par E. F. Moore, qui l'a utilisé pour
trouver le chemin le plus court hors d'un labyrinthe, et découvert
indépendamment par C. Y. Lee en tant qu'algorithme de routage de câbles
(publié en 1961).

La recherche en profondeur d'abord (DFS) est un algorithme permettant de

parcourir ou de rechercher des structures de données arborescentes ou
graphiques. On commence à la racine (en sélectionnant un nœud arbitraire
comme racine dans le cas d'un graphe) et on explore le plus loin possible le long
de chaque branche avant de revenir en arrière.

19
 Étant donné que la recherche en largeur d'abord (breadth-first) semble éviter le problème de
récursivité infinie, on peut se demander pourquoi elle n'est pas utilisée pour la recherche en
premier lieu ?
◦ La réponse est due à des considérations d'efficacité. Beaucoup plus d'informations devraient être
conservées au moment de l'exécution (en fait, toutes les informations de l'arbre jusqu'à ce point),
avec une recherche en largeur d'abord. La recherche en profondeur d'abord (depth-first) peut être
mise en œuvre beaucoup plus efficacement à cet égard. Mais, comme c'est souvent le cas, le gain
d'efficacité a un coût. Dans ce cas, le coût est considérable dans la mesure où il oblige les
programmeurs à être prudents et conscients de la façon dont les programmes sont exécutés et à
organiser leurs programmes en conséquence. L'ordre dans lequel les clauses d'un prédicat
apparaissent sera important (profondeur en premier). En particulier, la possibilité d'une récursivité
infinie doit être évitée, soit en plaçant au moins une clause non récursive avant les clauses
récursives, soit en s'assurant que la tête des clauses récursives ne s'unifiera pas à un moment
donné avec un objectif.

20
  L'intelligence artificielle (IA) fait référence à des systèmes
ou à des machines qui imitent l'intelligence humaine pour
effectuer des tâches et peuvent s'améliorer de manière
itérative en fonction des informations qu'ils collectent.

 L'IA se manifeste sous plusieurs formes :

◦ Les chatbots utilisent l'IA pour comprendre plus rapidement
les problèmes des clients et fournir des réponses plus
efficaces
◦ Les assistants intelligents utilisent l'IA pour analyser les
informations critiques de grands ensembles de données en
texte libre afin d'améliorer la planification
◦ Les moteurs de recommandation peuvent fournir des
recommandations automatisées pour les émissions de
télévision en fonction des habitudes de visionnage des
utilisateurs

L'IA concerne bien plus le processus et la capacité de réflexion surpuissante et

d'analyse de données que tout format ou fonction en particulier. Bien que l'IA évoque
des images de robots hautement fonctionnels ressemblant à des humains prenant le
contrôle du monde, l'IA n'est pas destinée à remplacer les humains. Il vise à améliorer
considérablement les capacités et les contributions humaines. Cela en fait un atout
commercial très précieux.

Le principe central de l'IA est de reproduire - puis de dépasser - la façon dont les
humains perçoivent et réagissent au monde. Il devient rapidement la pierre angulaire
de l'innovation. Alimentée par diverses formes d'apprentissage automatique (Machine
Learning) qui reconnaissent les modèles de données pour permettre des prédictions,
l'IA peut ajouter de la valeur aux entreprises en :
1. Fournir une compréhension plus complète de l'abondance des données disponibles
2. S'appuyer sur des prédictions pour automatiser des tâches excessivement
complexes ou banales

21
  C’est un paradigme diffèrent, basé sur des algorithmes capables
d'apprendre à partir des données sans s'appuyer sur la "programmation
basée sur des règles".
 Autrement dit, avec les mégadonnées, vous avez beaucoup de données.
Déterminer quoi en faire et comprendre ce qu'il vous dit n'est pas facile.
 Vous pouvez donc comprendre l'attrait de l'apprentissage automatique, qui
vous permet essentiellement de trouver la puissance de traitement et le
bon algorithme et de leur dire de comprendre les choses pour vous.

 L'apprentissage automatique applique des modèles statistiques aux

données dont vous disposez afin de faire des prédictions intelligentes sur
les données que vous n'avez pas.
https://hbr.org/2015/11/how-machines-learn-and-you-win

L'analogie est avec la façon dont nous apprenons en tant qu'êtres humains, en faisant
l'expérience du monde qui nous entoure et en résolvant les choses par nous-mêmes.
Lorsque vous apprenez aux enfants à faire du vélo, vous ne leur donnez pas "Les
règles du vélo". Vous les mettez sur un vélo, vous les tenez dessus et vous les laissez
s'en sortir. Ils prennent des entrées de données de leurs yeux, de leurs oreilles et, à
certaines occasions, d'un gros buisson, et commencent à découvrir ce qui maintiendrait
le vélo droit. Il en va de même avec l'apprentissage automatique. Prenez les données,
travaillez avec et voyez ce qui en ressort.

Il est devenu une discipline scientifique à la fin des années 1990, car les progrès
constants de la numérisation et la puissance de calcul bon marché ont permis aux
scientifiques des données d'arrêter de construire des modèles finis et de former des
ordinateurs à le faire. Le volume et la complexité ingérables des données
volumineuses dans lesquelles le monde nage actuellement ont accru le potentiel de
l'apprentissage automatique - et sa nécessité.
En 2007, Fei-Fei Li, le chef du laboratoire d'intelligence artificielle de Stanford, a
renoncé à programmer des ordinateurs pour reconnaître des objets et a commencé à
étiqueter les millions d'images brutes qu'un enfant pourrait rencontrer à l'âge de trois
ans et à les transmettre aux ordinateurs.

22