IntroductionAux Systèmes multi-agents

Syma – cursus CSI / SCIA

Julien Saunier - julien.saunier@ifsttar.fr

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