Embed Size (px)
Citation preview
Ressources
Multiagent Systems, A Modern Approach to Distributed Artificial Intelligence Edited by Gerhard Weiss, MIT Press.emmanuel.adam.free.fr/site/IMG/pdf/poa_introP.pdfwww.limsi.fr/~jps/enseignement/www.emse.fr/~boissier/www.ecs.soton.ac.uk/about/pdfs/AgentLink_Fifty_Facts.pdfwww.agentlink.org/roadmap/al3rm.pdfwww.lirmm.fr/~ferber/
Cours (librement et fortement) inspiré de ceux de Flavien Balbo et Nicolas Sabouret
Plan
● Introduction aux SMA– Historique, Définitions, Propriétés, Typologie
● Modélisation multi-agents : agents réactifs– Méthodologie Voyelle– Exemples
● Architectures d'agents rationnels– BDI / Logique– Modèles d'interaction...
● Simulation multi-agents– Systèmes complexes– Emergence & multi-agents–
Évaluation
● 50% examen– Premier partiel en avril
● 50% projet
Les Systèmes Multi-Agents
Une introduction
Nicolas Sabouret Module IAA – Septembre 2010
Plan● Introduction
– Introduction & historique– Définition : agent & SMA– Définition des notions clefs
● Modélisation: agents réactifs– Agent– Environnement– Interaction– Organisation– Utilisateur
Plan● Introduction
– Introduction & historique– Définition : agent & SMA– Définition des notions clefs
● Modélisation: agents réactifs– Agent– Environnement– Interaction– Organisation– Utilisateur
Objectifs
autonomieouverture
hétérogénéïté
asynchrone
cognitif
proactif
rationnel
faiblement couplé
coopératifcoordination
agent situé
interaction
SMA
Environnement
organisation
émergence
Exemple Jeu
10
Exemple robots
IntroductionOrigine
● Source– Intelligence Artificielle,– Informatique répartie, parallélisme,– Programmation, Objet.
● Inspiration– Systèmes complexes (physique, éthologie,
écologie, …)– Psychologie sociale, sociologie, économie, …
Point de vue IA● IA symbolique :
– Logique(s)– Représentation des connaissances & raisonnement
→ données et actions (planification, apprentissage)– Modélisation & résolution de problèmes
● Problème : – Conception d'une IA générale monolithique?
● Non, mais spécialisée (Ex: Big Blue)
Point de vue IA (2)
● Lier l'IA symbolique aux leçons des sciences cognitives :
– Simulation de comportement humain– Sociétés d'animaux (fourmis) → interactions– Simulation sociale
● Intelligence Artificielle Distribuée
Point de vue GL● Programmation impérative : fonctions● Programmation objet :
– Encapsulation → invocations de méthodes● Programmation services :
– Invocation à distance (RMI)– Indépendant du langage
● Programmation orientée-agents : processus– Pro-action (vs invocation modale)– Appels asynchrones– Délégation de tâche
Point de vue GL (2)● 1 agent = 1 thread
– Données et méthodes encapsulées– Interface d'invocation → service
→ Couche de communication mi-reseau, mi-langage
● SMA = ensemble de threads– Notion de système « ouvert »– Définition de « protocoles d'interaction »
pour la conception du système● Comment concevoir (ingénierie) un tel système ?
Point de vue SR● Informatique centralisée
– Calculateurs & « back-office »● Client-serveur → « synchronisation »
– Front-end (client)– Bases de données (serveur)
● Systèmes distribués → « répartition »– Internet, pair à pair, MANET– Délégation, migration, authentification– Coordination– Composition (auto) de services
Point de vue SR (2)
● Agent → métaphore des unités de calcul hétérogènes
– Capacités hétérogènes (proc, batterie...)– Couche de communication (réseau)
éventuellement instable● Questions
– Tolérance aux pannes → réplication– Réseau changeant et portée limitée → brokering– Fiabilité des communications– Authentification
Et donc?● Agent
– Processus– Encapsulation– Raisonnement sur les actions– Services
● SMA– Système (ouvert), environnement– Distribution, coordination– Invocation, Interactions
● Utilisateur !
Agent
&
Système Multi-Agents
Un agent ? Quelques définitions
● [ Ferber 91] : Entité physique ou virtuelle mue par un ensemble de tendances (objectifs individuels, fonction de satisfaction ou de survie à optimiser), qui possède des ressources propres, ne dispose que d'une représentation partielle (éventuellement aucune) de son environnement, son comportement tendant à satisfaire ses objectifs, en tenant compte de ses ressources et de ses compétences, et en fonction de sa perception, ses représentations et ses communications.
● [IBMWhite paper, 95] : Un agent intelligent est une entité logicielle qui réalise des opérations pour le compte d'un usager (ou d'un autre programme) avec un certain degré de liberté et d'autonomie et qui, pour ce faire, exploite des connaissances ou des représentations des désirs et des objectifs de l'usager.
● [P. Maes, 95] : Un agent autonome est un système calculatoire qui, placé dans un environnement complexe et dynamique, perçoit et agit de manière autonome dans cet environnement et, ce faisant, réalise les objectifs ou des tâches pour lesquels il est conçu.
● [Wooldridge 97] : Un agent est un système informatique situé dans un environnement, capable d’actions flexibles et autonomes dans cet environnement, pour atteindre le but pour lequel il a été conçu.
Notion d'agent
Agentréactif
Agentcognitif
Agentrationnel
Données Internes(croyances)Action
Raisonnement(inférence)
Interactionsdirectes
Planification
Butsexplicites
● Agent → actions– Agent réactif : règles perception → action– Agent cognitif/rationnel : raisonnement
● Rationnalité → but
→ Construction de plans
Agent (1)● Environnement
– Pas d'agent sans environnementInitialisation et exécution des agents
– Peut être réduit à des fonctions I/O– Souvent : fournisseur de l' « agent ID »
● Processus– Thread ou scheduler dans l'environnement– Boucle procédurale (actions)
● Exemples
Premier exemple
● Pas de donnée propre → plutôt « réactif »● Pas de perception, pas d'interaction● Action sur l'environnement● Processus = thread● Boucle procédurale
public class Agent1 extends Thread { public void run() { while (true) { System.out.println("coucou"); } } public static void main(String [] args) { (new Agent1()).start(); }}
Action dansl'environnement
Environnement(lance l'exécution + I/O)
Deuxième exemple
● Processus = simulé par l'environnement● Boucle procédurale : run1step (masquée dans l'ex. prec.)
import java.util.Random;
public class Agent2 { public void run1step() { System.out.println("coucou"); } public static final int N = 10; public static void main(String [] args) { Random r = new Random(); Agent2[] agents = new Agent2[N]; for(int i= 0;i<N;i++) agents[i] = new Agent2(); while (true) agents[r.nextInt(N)].run1step(); }}
Boucle procédurale→ action dansl'environnement
Environnement
Scheduler
Liste des agents
Agent (2)● Un environnement● Un processus
→ peut être simulé (scheduler)● en interaction avec l'environnement
– Actions– Perceptions
→ l'agent est situé
Perception● Temps de perception
– Synchrone → à chaque cycle d'exécution– Asynchrone → seulement de temps en temps
● Méthode de perception– Passive → l'agent est informé automatiquement– Active → une ou plus. actions « percevoir »
● Rôle des perceptions– Mise à jour de données internes (agent cognitif)– Réaction (agent réactif)
→ Architecture dépendant de l'environnement et de la boucle procédurale !
Boucle procédurale● Ensemble d'actions + exécution cyclique● Sélection d'action
– En fonction des connaissances internes (agent cognitif)– En fonction des perceptions (agent réactif)
● Trois types d'actions– Actions exogènes → environnement
(écrire « coucou »)– Actions internes → données
(en particulier l'action de perception, si elle existe)– Interactions (voir + loin)
Troisième exemple
● Perception active, asynchrone
Thread[Thread-0,5,main]v=1279Thread[Thread-0,5,main]v=1280Thread[Thread-0,5,main]v=1279Thread[Thread-0,5,main]v=1280Thread[Thread-0,5,main]v=1287Thread[Thread-1,5,main]v=1219Thread[Thread-1,5,main]v=1220Thread[Thread-1,5,main]v=1220Thread[Thread-1,5,main]v=1220Thread[Thread-1,5,main]v=1221
static int env_v = 0;… main() { for(int i<0;i<N;i++) (new Agent3()).start();}
int v = 0;private void a1() { v = env_v; }private void a2() { v++; }private void a3() { env_v = v; }private void a4() { …println(this.toString()+"v="+v);}
public void run() { while (true) { switch (r.nextInt(4)) { case 0: a1(); break; case 1: a2(); break; case 2: a3(); break; case 3: a4(); break; } }}
Environnement
Agent
Un problème SR & GL● Accès concurrent à une ressource
– Risque d'interblocage (au niveau du système)(ici, lecture et incrément → pas de blocage)
– Différence interne/environnement (au niveau de l'agent)
● Problématique multi-agent
→ concevoir des systèmes qui intègrent :– Le fait que les données ne sont pas à jour ;– La modification concurrente des données
Quatrième exemple
● Perception passive (peer)● Interaction uniquement entre agents (pik-pok)
… main() { Agent4 a = new Agent4(), b = new Agent4();
a.setPeer(b); b.setPeer(a);a.start(); b.start();
}
private Agent4 peer = null;public setPeer(Agent4 p) { peer = p;}
public void pik() { …println(this.toString()+": pok");}public void foo() { if (peer!=null) peer.pik();}
public void run() { while (true) { foo(); }}
Environnement Agent
Connaître les autres agents...
...pour communiquer avec eux !
L'agent a 2 actions (pik et foo)
Agent (2)● Un processus● Situé dans un environnement● Des données et des actions
→ plus ou moins complexes● Des mécanismes d'interaction
→ avec l'environnement
→ avec les autres agents(éventuellement de manière indirecte)
● Des objectifs propres !
→ explicites ou implicites
Notion de but● Fonctionnement pour l'utilisateur
– Au niveau de l'agent– Au niveau du système
● Une première idée d' « autonomie »– Chaque agent a ses propres buts
(et ses propres données, actions...)– La sélection d'action doit se faire en fonction de ces
buts → agent « intelligent » !
Définition● Un agent est :
– Un processus (situé dans un environnement)– Qui manipule des données et des actions– Qui peut interagir avec l'environnement ou avec
d'autres agents– Qui a des objectifs propres
● Un système multi-agents est :– Un ensemble d'agents + un environnement– Un fonctionnement global + un ensemble de
propriétés – Un mécanisme de décision distribué
Système Multi-Agents● Ensemble d'agents + environnnement
→ plate-forme d'exécution !● Rôles de la plate-forme (matérielle ou logicielle)
– Exécution des agents (threads ou scheduling)
– Lien entre les agents● Adressage, identification● Transport des messages, invocation de mtds
– Environnement● Données de l'environnement● Actions & perceptions
Système Multi-Agent
Agents
+
Interactions
+
Environnement
+
Utilisateur !
SMA
Les 3 niveaux du SMA● Le niveau « processus »
– Programmation (en langage objet en général)
– Définition du comportement (pas « autonome »)
● Le niveau agent– Encapsulation + méthodes de communication– Comportement « autonome »– Pas de vision globale
● Le niveau Système– Définition de l'environnement
dont règles globales (régulation)– Propriétés
Propriétés● Du système multi-agent
– Distribution– Ouverture– Synchronisme– Mode d'interaction– Couplage– Homogénéité– Organisation
● Des agents– Autonomie– Coopération– Modèle de raisonnement
SMA → ingénierie+rechercheQu'est-ce qui rend les SMA si intéressants ?
● Ensemble d'agents ayant des objectifs propres
→ les agents doivent se coordonner !
→ le comportement du système peut émerger !● Questions de recherche :
– Propriétés du système, des agents– Métaphore humaine, sociale...– Simulation
● Ingénierie– Conception & implémentation– Mécanismes d'interaction
Conclusion (1)
actions perceptions
communication
représentation● soi● les autres● l'environnement
environnement
utilisateur
proaction
Conclusion (2)● Agent ≠ imprévisible !
Voir « autonomie »...● SMA ≠ technique IA
La partie cognitive de l'agent peut être un système expert, un réseau bayésien, etc.
SMA → approche, architecture, problématiques(interactions, émergence, etc)
Définitions
Définitions● Distribution● Ouverture● Synchronisme● Hétérogénéité● Couplage● Autonomie● Coopération● Rationalité● Mode d'interaction● Organisation
Distribution● Un SMA est un système réparti
– Conceptuellement (a minima)Penser le système comme un ensemble d'entités séparées, avec leurs fonctionnalités
→ le mécanisme de décision est distribué !– Logiquement
L'implémenter comme tel– Physiquement
Sur plusieurs machines
→ la plupart des PF SMA n'adoptent pas ces trois degrés !
Distribution● Distribution conceptuelle
– Chaque agent possède:● Un ensemble de données propres● Des opérations spécifiques sur ces données
– Attention aux interactions→ si on se dit tout, ça n'est plus distribué
● Distribution logicielle– Les agents sont implémentés de manière séparée– Leur exécution est distribuée (N threads)
mais on peut recréer un scheduler (ex: Netlogo)– Généralement, 1 agent = 1 objet
Distribution● Envoi de messages
– Il faut un mécanisme central pour transporter les messages
– Peut être distribué (brokers, adressage, DNS)● Horloge → voir synchronisation● Plate-forme répartie (ex : Jade)
– Migration
→ l'agent se « déplace » physiquement sur la plate-forme concernée
● Sureté de fonctionnement
→ réplication d'agents (et donc de données)
Distribution● Distribution matérielle
– Plusieurs plate-formes physiques
→ il faut compléter les mécanismes de distribution logicielle par:
● Invocation de méthodesRMI, Web Services, TCP/IP, autres…
● Mécanismes de gestion des pannes physiques(perte sèche des agents, encore plus présent qu'en distribution logicielle)
– Attention au coût des communicationset de la synchronisation des données
2 plate-formes● En Netlogo
→ on conçoit le SMA de manière distribuée
→ il est implanté de manière centralisée
→ sur une seule plate-forme● En Jade
→ on conçoit le SMA de manière distribuée
→ il est implanté de manière distribuée
→ il peut être physiquement distribué
OuvertureLes agents peuvent entrer et sortir du système à tout moment en cours d'exécution
● Il faut des mécanisme d'enregistrement
→ Plate-forme SMA (répertoire, pages jaunes, etc...)
● Il faut en tenir compte dans le modèle !(cf. autonomie dans les interactions)
La solution est au niveau système
L'implémentation est au niveau agent→ les agents peuvent disparaître !
● Il faut des mécanismes de naissance & mort
Exemple
● Soldat : durée de « vie » aléatoire● Sergent : compter les soldats actifs
Sergent
Soldats
depot = new ArrayList<Soldat>();GetDepot() → return depot; /* ou une copie */public static void main(String [] args) {
(new Sergent()).start();while (true) { Thread.sleep(1000); Soldat s = new Soldat(); depot.add(s); s.start();}
}
Environnement
Création d'agents
Exemple (suite)class Soldat extends Thread { boolean running = true; public boolean appel() { return running; } public void run() { running = true; …println("** POP **"); Thread.sleep(rand(10000)); …println("> depop >"); running = false; }}
Soldat
class Sergent extends Thread { public void appel() { int nb = 0; for(Soldat s : getDepot())
if (s.appel()) nb++; …println(" => "+nb); } public void run() { while (true) { Thread.sleep(3000); appel(); } }}
Sergent
Méthode d'appel
Mort de l'agent ?
● Ici, les « soldats » ne quittent pas le SMA
→ ils répondent aux messages du « sergent »
Exemple (suite)● Arrivée d'agents
→ consulter l'annuaire
→ rappelle N fois les soldats toujours vivants !L'agent devrait avoir une mémoire...
● Les soldats restent dans le SMAMais s'ils le quittaient (destruction de l'objet) ?
→ risque de blocage du sergent (attente de réponse)
→ la PF SMA doit gérer les messages perdus, en attente, etc
→ Il faut un autre mécanisme d'interaction !– Appel de méthodes → pas SMA– Plate-forme : adressage, transport...
AsynchroneChaque agent a sa propre vitesse d'exécution
● Propriétés souhaitées– Le temps moyen d'activité de chaque agent est le
même pour tous– La « vitesse perçue » des agents ne change pas
trop
● SMA synchrones
Ex : apprentissage multi-agent !
Exempleint id; /* unique */int vitesse = rand(1000);public void run() { while (true) { Thread.sleep(vitesse); if (verrou==id) verrou=1; else if (verrou==1) { verrou=id;
…println("Je l'ai !"); }}
Agent
$ java Asynchrone (0) vitesse=166(1) vitesse=894(2) vitesse=847[...](1) Je l'ai !(0) Je l'ai !(0) Je l'ai !(2) Je l'ai !(0) Je l'ai !(1) Je l'ai !(0) Je l'ai !(2) Je l'ai !(0) Je l'ai !(0) Je l'ai !(0) Je l'ai !(2) Je l'ai !
Environnement
static int verrou = 1;public static void main(...) { for(int i=0;i<3;i++) (new Asynchrone()).start(); }}
Exemple (suite)● Problèmes posés
– Risque de famine→ un agent n'arrive pas à « attraper » la ressource
– Interactions → retard dans les réponses→ raisonnement sur des données erronées
● SMA synchrone
→ en général, un scheduler régulier
ATTENTION :Ne pas tirer toujours les agents dans le même ordre !
Hétérogénéité● 2 Niveaux:
– Données internes des agents ou de l'env.– Contenu des messages
● Hétérogénéité syntaxique
→ Les agents ne partagent pas le même modèle de données (BDI, CLIPS, DL, autre)
Peu utilisé en pratique dans les SMA
→ Normes (FIPA) & langages standards
(is-into epita) (let x 3)in(epita) x:=3
Exemple
● Interactions indirectes (variable BAL)● Agents hétérogènes → échec
générer
filtrer
static final String SAIN = "sane";static final String A_EXAMINER = "check";static final String DANGEREUX = "danger";
Producteur
[...]Production (7): dangerProduction (8): checkProduction (9): checkProduction (0): check** ok null ok null ok null ok null ok ok **
Environnement
static String [] BAL;
static final String DANGER = "danger";static final String VERIFIE = "checked";public void run() { while (true) if (BAL[i]!=null) BAL[i] = filtrer(BAL[i]);}private String filtrer(String dt) { if (!dt.equals(DANGER)) return CHECKED; return null;}
Filtre
Hétérogénéité● Sémantique
→ Les agents ne partagent pas la même conception du monde
● Solution :
→ Utiliser la même représentation du monde(voir SMA faiblement couplés)
→ Ontologies + services d'appariements
is(plant,safe) ?
Ontologie● Kesako ? (au sens multi-agents !)
– Ensemble des données manipulables par l'agent– Généralement structurée :
● Relation hiérarchique● Relations entre les termes
● Objectif– Cohérence dans les interactions multi-agents– Interactions structurées (cf. plus loin)
tenirverrou
libre
verrouilléagent
processus
software
Hétérogénéité
● Appariement d'ontologies– Approches par instances vs par structure– Approches par ontologie médiatrice– Problème des appariements impossibles
SMA faiblement coupléLes agents ont été conçus par des personnes différentes, sans connaissance du fonctionnement des autres agents
● Pas si fréquent→ mais modèle business d'entreprise
● Faiblement couplé ≠ hétérogène– Évitez de cumuler les difficultés !
→ ontologie standard● Définition des protocoles d'interactions
– Fixer les échanges de messages– Sélection de protocoles
SMA faiblement couplé● Fortement couplé (1 seul concepteur)
– Buts du SMA définis implicitement– Émergence de comportements de haut niveau– Analyse, debug, chaîne GL plus facile– Pas besoin de découverte de service
● Mais:– Système souvent fermé et homogène– Difficulté de l'ingénierie à l'échelle (nb d'agents)
Autonomie● Notion clef en SMA
→ différence entre agent et objet !● Autant de définition que de chercheur en M.A.
– Autonomie = proaction→ capacité d'agir seul
– Autonomie = encapsulation→ données propres
→ liberté d'action (limitée par l'environnement)– Autonomie = non-réponse aux messages
ou réponse non-conforme
→ limitée par les protocoles
Proaction: agent vs objet● Snoopy = agent
– Il peut envoyer la balle– Il peut ne pas l'envoyer
● Balle = objet– Elle obéit aux lois de la physique lorsque snoopy la
lance– Elle n'agit pas seule. Elle n'a pas d'action.
● Objet → donnée de l'environnement● Agent autonome → action et pro-action
Exemple filtre : proactions !
Encapsulation & liberté d'action
● Un agent agit comme il veut (peut!)● Un agent fait ce qu'il veut sur ses variables
internes
… mais pas sur les variables d'environnement
… ni sur les variables des autres agents
Autonomie d'interaction● Envoi de message → réponse
La réponse peut prendre n'importe quelle valeur !● Exemple
public class Autonome extends Thread { private Autonome peer; /* set by env */ private int x = 0, i = 0; public void run() { while(true) { i++;
if (i%100==0) x++; if (i==500) println(peer.getX()); if (i==1000) i = 0;
} } public int getX() {
if (i%2==0) return x/2;else return x;
}}
Agent
Du point de vue d'un agent, la réponse du ”pair” est imprévisible.Le ”pair” est autonome...
Coopération● SMA coopératif vs compétitif
– Les agents partagent des buts● De manière explicite (buts communs)● De manière implicite (tâches convergentes)
≠ ils participent tous de la même activité globale → toujours vrai dans un SMA
– Les ressources sont :● Soit suffisantes● Soit partagées équitablement
– Les agents sont honnêtes (non-byzantins)● Normes à respecter● Environnement ou agent censeur
– Les agents peuvent aider les autres agents
Coopération (2)● Exemples de SMA compétitifs
– SMA d'enchères (très souvent)● Protocoles d'enchères gérant la compétition
– Simulation (souvent)● Marché du travail● Trafic (réel)
● Exemples de SMA coopératifs– Simulation de transports autonomes
● Tous les agents s'aident
Agent rationnel
● Rationnel = modèle orienté but– But explicite → construction de plans– Planification multi-agents– Sélection de plans– ex : modèle BDI
