2. Architectures des agents et langages
2.3 Langages orientés agents

2.3.2 Programmation orientée agents

La programmation orientée agents a été proposée par Yoav Shoham en 1993 comme un nouveau paradigme de programmation, que l'on peut voir comme une spécialisation de la programmation orientée objets. Dans cette approche, les agents sont les éléments centraux du langage, de la même façon que les objets sont centraux pour les langages orientés objets. La perspective sur les agents est cognitive : les agents sont caractérisés par des notions mentales comme leurs croyances, leurs décisions et leurs obligations. De plus, à chaque agent est associé un ensemble d'habiletés qui représentent ce que l'agent sait faire. En même temps, la programmation orientée agents suppose qu'on va développer des programmes dans lesquels plusieurs agents interagissent, ce qui met l'accent sur la dimension sociale des agents. Le langage de programmation proposé par Shoham comme démonstration de ce nouveau paradigme s'appelle AGENT0.

La différence principale entre un tel langage et un langage de programmation classique que l'on pourrait utiliser pour développer des agents, vient du fait que les notions mentales qui caractérisent les agents apparaissent dans le langage lui-même, et que la sémantique du langage est intimement liée à la sémantique de ces notions mentales. La programmation orientée agents peut être vue comme une spécialisation de celle orientée objets parce que les modules du programme sont maintenant des agents, c'est-à-dire des objets avec un état qui définit les notions mentales associées, et que les messages entre objets sont remplacés par des messages entre agents. En quoi les messages entre agents différent-ils de ceux entre objets ? Premièrement, parce que ces messages sont modélisés en partant de la théorie des actes de parole, qui s'intéresse aux actions de communication comme informer, demander, offrir, accepter, rejeter et d'autres (pour la théorie des actes de paroles, souvenez vous ce qu'on a présenté dans le chapitre 1 ou lisez le chapitre 4). Deuxièmement, puisque les agents sont autonomes et dotés de capacités mentales, ils ont la liberté de décider s'ils vont ou non exécuter l'action spécifiée dans le message. Par contraste, un objet recevant un message va toujours exécuter l'action spécifiée dans le message. Cette spécialisation même fait que la programmation orientée agents est différente de celle orientée objets comme le montre le tableau ci-dessous, tableau de différences établi par Shoham.

Programmation Orientée Objets versus Programmation Orientée Agents

Avec l'évolution des théories concernant les agents et des langages de programmation associés, on peut également souligner d'autres différences entre POO et POA :

• les agents sont autonomes alors que les objets ne le sont pas ; un agent va décider par son propre processus de décision s'il exécute ou non une action requise ;
• les agents ont leurs propres buts et ils agissent d'une manière pro-active pour atteindre leurs buts (par exemple, ils saisissent des opportunités) alors que les objets ne le font pas ;
• les agents sont capables d'un comportement social : ils peuvent s'engager dans des interactions complexes, par exemple coopération, compétition, négociation, avec d'autres agents ; ce n'est pas le cas des objets ;
• un système multi-agents est, normalement, un système dans lequel les agents correspondent à des chemins d'exécution séparés ; chaque agent a son propre chemin d'exécution alors que les objets, à part les objets concurrents, ne présentent pas cette caractéristique.

Le débat sur la différence entre agents et objets est encore ouvert, et on peut ajouter d'autres arguments à ceux mentionnés ci-dessus. En parcourant ce cours, vous pourrez décider par vous-mêmes quelles sont les différences les plus importantes, ou même s'il y a des différences.

Les notions mentales des agents AGENT0

Le langage AGENT0 part d'un modèle de logique modale qui définit la sémantique des constructions du langage. Shoham propose les opérateurs modaux B, CMT, DEC et CAN pour représenter les notions mentales des agents et donne les axiomes qui caractérisent ses opérateurs.

Pour en savoir plus sur la logique modale et les diverses modalités vous pouvez parcourir notre premier cours en ligne

Les agents AGENTS agissent dans un environnement où le temps est discret et linéaire et ils sont caractérisés par les notions mentales suivantes :

• Croyances ; B_a^t a - à l'instant t, l'agent a a la croyancea ;
• Obligations ; CMT_a,b^t j - à l'instant t, l'agent a s'est obligé àfaire j pour l'agent b ; j est une action ;
• Décisions ; DEC_a^tj = CMT_a,a^t j - à l'instant t, l'agent a a décidé de faire l'action j ; on peut voir que, dans ce modèle, une décision est considérée comme une obligation envers soi-même ;
• Habilités ; CAN_a^tj- à l'instant t, l'agent a est capable de faire l'action j.

Le modèle suppose que les croyances et les obligations sont consistantes, notamment que l'agent n'a ni croyances contradictoires, ni obligations contradictoires, et qu'il applique une stratégie d'obligation aveugle. Les actions d'un agent sont de deux types : des actions privées que l'agent peut exécuter par lui-même, sans l'aide des autres agents, et des actions communicatives qui représentent des messages envoyés à d'autres agents.

Le langage AGENT0

Les composantes principales du langage AGENT0 sont :

• instructions factuelles ; (t  (employé  pierre  ibm)) - il est vrai que Pierre est employé par IBM
• instructions pour l'exécution des actions privées ; (DO  t1  ouvre-porte) - l'agent exécute l'action privée ouvre-porte à l'instant t1 ;
• instructions pour des actions communicatives :
  • (INFORM  t1  b  fait) - l'agent informe un autre agent b qu'il croit que le fait est vrai à l'instant t1 ;
  • (REQUEST  t1  b  action) - l'agent demande à l'agent b d'exécuter à l'instant t1 ;
  • (UNREQUEST  t1  b  action) - l'agent retire sa demande à l'agent b d'exécuter l'action à l'instant t1 ;
  • (REFRAIN  action) - l'agent ne doit pas s'obliger à exécuter l'action ;
• représentation des conditions mentales dans le langage :
  • (B (t fait)) - représente B_a^t a, où a=fait; l'agent a est implicite dans cette représentation car il s'agit de son programme ;
  • ((CMT t b) action) - représente CMT_a,b^t j où j=action ;
  • ((DEC t) action) - représente DEC_a^t j, où j=action ;
  • (CAN t) action) - représente CAN_a^t j, où j=action ;
• instructions pour des actions conditionnées ; la forme générale de ces instructions est :
  (IF condition-mentale  action), par exemple :
  
  (IF  (B  (t  (valeur  actions 100)))
                          (INFORM   t1  b  (t  (valeur  actions 100))))
• règles d'obligation ; ces règles représentent la clé de ce langage orienté agents et indiquent les conditions sous lesquelles un agent assume une certaine obligation ; la forme générale d'une règle d'obligation est :
  (COMMIT  condition-message condition-mentale (agent  action))

La condition mentale a la forme présentée plus haut ; la condition du message a pour rôle d'identifier le type de message reçu et l'action spécifiée dans le message, l'agent fait référence à l'agent envers lequel on prend l'obligation.

Une règle d'obligation dit qu'un agent s'oblige à faire une certaine action si :

• la condition message est satisfaite par le message reçu ;
• la condition mentale est vraie dans l'état courant de l'agent ;
• l'agent est capable de faire l'action spécifiée dans la règle ;
• l'agent n'a pas l'interdiction d'exécuter l'action (REFRAIN)

Un exemple de règle d'engagement est :

(COMMIT  (?b  REQUEST  ?action)
                                                (B  (now  (mon_ami  ?b)))
                                                (?b  ?action))

où par ?b on indique un agent quelconque (le préfixe ? indique les variables du langage) ; cette règle signifie que si l'agent reçoit un message de demande (REQUEST) pour effectuer une certaine action (?action), et s'il croit qu'à l'instant présent (now) l'agent ?b est son ami alors notre agent s'oblige envers ?b à exécuter l'action ?action. Pour un message particulier, disons (Pierre REQUEST achete_livre) notre agent va s'obliger envers Pierre (?b), si Pierre est son ami, d'exécuter pour lui l'action achete_livre (?action).

L'exécution des programmes

Pour écrire un programme en AGENT0, on définit d'abord les croyances initiales et les habiletés des agents du programme. On écrit ensuite les règles d'obligation qui définissent le comportement de chaque agent. Ensuite, l'interprète du langage AGENT0 va exécuter la boucle de contrôle suivante pour chaque agent :

1. lire les messages reçus
2. actualiser les croyances en fonction de ces messages
3. déterminer les obligations en appliquant les règles d'obligation dont les conditions sont validées
4. exécuter les obligations courantes
            - si obligation = action privée alors exécuter action
            - si obligation = instruction conditionnelle alors
                        - vérifier condition mentale
                        - si la condition mentale est vérifiée dans l'état de l'agent
                        - alors exécuter action associée
            - si obligation=action communicative alors envoyer message associé
fin

Dans le langage, chaque agent est exécuté par un chemin d'exécution indépendant, et il y a un mécanisme qui assure la transmission des messages entre agents.

Le langage AGENT0, bien que permettant le développement d'applications déjà assez élaborées avec des agents, n'est qu'un prototype. Il est important en tant qu'exemple illustrant le paradigme de programmation orientée agents, parce qu'il a inspiré d'autres langages de programmation orientés agents et parce qu'il a montré comment on peut réaliser une correspondance étroite entre les concepts de la théorie des agents et leur programmation.

Question: Dans la boucle de contrôle d'un agent AGENT0, si l'obligation courante à exécuter est (REFRAIN action) est-ce que l'agent doit envoyer un message ?

Cliquer ici pour voir la réponse

Il faut noter que, par rapport aux architectures d'agents cognitifs présentées dans la section antérieure, le langage AGENT0 comprend aussi bien des notions cognitives que la dimension sociale des agents, notamment la communication entre agents. En fait, l'idée clé du langage est cette dimension sociale. Quand on a discuté les architectures d'agents, à l'exception de l'architecture du système InteRRaP, on s'est concentré uniquement sur la structure d'un seul agent. Dans les chapitres qui vont suivre, on va bâtir sur ces architectures la dimension sociale des agents. L'exemple de AGENT0 sera un bon guide pour cela.