LES AGENTS INTELLIGENTS SUR
INTERNET
IRESTE
DUTIL 10
Stéphane Anglerot, Guillaume
Bonnet, Guy Regnault
LES AGENTS INTELLIGENTS SUR
INTERNET
IRESTE
DUTIL 10
Stéphane Anglerot, Guillaume
Bonnet, Guy Regnault
Table des Matières
Introduction...................................................................................................... 4
Présentation..................................................................................................... 4
Problématique................................................................................................. 4
Plan du document.......................................................................................... 4
Définition des termes et
notions........................................................... 5
1 Généralités.................................................................................................. 8
1.1 Les caractéristiques des Agents.................................................... 8
1.2 Les types d’Agents................................................................................ 11
1.3 Les acteurs de la technologie Agent........................................ 16
1.4 Conclusion - Bilan............................................................................... 18
2 Mise en œuvre........................................................................................... 20
2.1 Les principes de la technologie Agent...................................... 20
2.2 Les langages........................................................................................... 23
2.3 Les outils.................................................................................................. 28
2.4 Les protocoles....................................................................................... 33
2.5 Sécurité et Ethique [CAG]................................................................... 35
2.6 Quelques Agents................................................................................... 36
2.7 Conclusion - Bilan............................................................................... 37
3 Perspectives d’avenir.......................................................................... 39
3.1 Les Agents perceront-ils ?............................................................... 39
3.2 Mise en place des Agents dans l’architecture n-tiers..... 39
Conclusion......................................................................................................... 45
Avertissement................................................................................................ 45
Paroles d’un visionnaire.......................................................................... 45
Bilan de la recherche................................................................................ 45
Perspectives de projet................................................................................ 46
4 Annexes......................................................................................................... 48
4.1 Annexe A – Liste des Agents............................................................. 48
4.2 Annexe B – Le chat et la souris...................................................... 53
4.3 Annexe C – Les universitaires......................................................... 55
4.4 Annexe D - Les Agents perceront-ils ?........................................ 56
4.5 Annexe E – Programme Prolog....................................................... 57
5 Bibliographie............................................................................................ 59
5.1 Bibliographie........................................................................................... 59
5.2 Cybergraphie........................................................................................... 59
5.3 Signets........................................................................................................ 60
6 Glossaire..................................................................................................... 65
Introduction
Depuis 1993 et le démarrage du World Wide Web, Internet fascine. A la fois, les techniciens, les hommes d’affaires, les banquiers. Même les romanciers, les hommes politiques et les mannequins s’y précipitent. Et depuis cette période, le nombre de sites, le nombre de pages, le nombre d’utilisateurs augmentent sans arrêt. Cet engouement ne tarit pas. Pour les américains, si friands de nouvelles frontières, le WEB est la dernière en date. Pour les bourses, la nouvelle économie fait rêver.
Mais quelques problèmes sont apparus, qu’il faudra régler afin de ne pas effrayer les investisseurs : les temps de réponse catastrophiques, les recherches difficiles dans cette montagne d’information, la sécurité des sites, la confidentialité des informations, la criminalité naissante, la protection de l’ensemble du réseau et son administration.
La technologie des Agents arrive à point nommé pour aider à gérer cette « gigantesque pagaille ».
La problématique de l’étude est : Découverte de la technologie Agent et de son application dans les réseaux internet.
Dans cette première partie, nous allons poser la définition de quelques termes importants.
Dans la deuxième, nous parlerons des caractéristiques des Agents et des différents types d’Agents. Nous présenterons quelques acteurs majeurs de la branche.
La troisième partie concernera la mise en œuvre des Agents : les principes de base, les langages utilisés, les outils et les protocoles. Nous évoquerons les problèmes de sécurité. Quelques exemples compléteront cette partie.
Dans la quatrième, nous présenterons les perspectives de la technologie Agent à l’aide de deux points de vue.
Le domaine des Agents est très récent. Les premières tentatives remontent tout au plus à quelques années et le terme d'Agent logiciel est encore mal défini.
Si on se réfère à la définition du dictionnaire : du latin :
« agens » : celui qui agit.
« Un Agent est une personne
chargée des affaires et des intérêts d’un individu, d’un groupe ou d’un pays,
pour le compte desquels elle agit »
Le terme « agir » est défini par le petit Larousse :
Agir (latin agere, faire) faire quelque chose, s’occuper, produire un effet.
De ces définitions on peut retirer deux aspects fondamentaux :
· un Agent accomplit quelque chose,
· un Agent agit à la demande de quelqu’un (Agent ou utilisateur).
Comme dans le cas de toute technologie nouvelle il n’y a pas de définition universelle, mais de multiples. Citons, par exemple, la définition donnée par Caglayan et Harrison [CAG] : Agent logiciel : entité informatique qui réalise de manière autonome des tâches pour un utilisateur.
On peut conclure de ces définitions qu’un Agent informatique (plus exactement une application Agent) devra faire quelque chose pour une personne ou une application.
Plus exactement une application Agent sera orientée tâche, c’est à dire qu’elle déploiera une activité (suite de fonctionnalités offertes par son environnement) dans le but de faire quelque chose et sera caractérisée par un certain degré d’autonomie, d’interactivité et de réactivité (ces notions seront développées plus loin).
Définition
« L’intelligence est l’aptitude à comprendre et à s'adapter à des situations nouvelles » (Définition de l’intelligence du Dr Franck Deroche-Gamonet dans le forum de discussion http://club.voila.fr/group/veille).
Pour un Agent, cette définition pose énormément de problèmes car il est très difficile de caractériser cette « aptitude à comprendre et à s’adapter à une situation nouvelle ». De nombreux auteurs ont donné leurs visions des choses mais aucune de ces visions n’est reconnue (un auteur = une définition). C’est pour cela que dans cette bibliographie, nous exposerons les caractéristiques d’intelligence d’un Agent en nous appuyant sur les travaux de Caglayan [CAG] et Nwana [NWA].
Ces auteurs décrivent l’intelligence d’un Agent comme un agrégat de caractéristiques : la capacité d’apprendre, la capacité sociale et un haut degré d’autonomie. Ces caractéristiques seront précisées dans la section suivante.
Le débat est interminable, peut-être insoluble, et sûrement sans grand intérêt pour l’utilisateur final. Beaucoup de sociétés, pour d’évidentes raisons de marketing, profitent de ce flou terminologique pour qualifier leurs produits logiciels d’Agents intelligents. Ce qui est clair, c’est qu’à cette heure, aucun Agent dit « intelligent », ne possède l’ensemble des caractéristiques de l’intelligence.
Notons qu’à ce jour, nombreux sont ceux qui débattent encore sur la définition du terme Client / Serveur et que cela risque fort de durer longtemps.
Pendant cette recherche, nous avons été confrontés au problème de traduire le mot intelligence. En anglais, ce mot est attaché à espionnage et cela pourrait entraîner des confusions. Les américains parlent d’Agents intelligents en utilisant les mots « intelligent Agent » alors que les anglais utilisent le mot « smart » (rusé, intelligent). Le contexte général fait toujours référence à l’intelligence artificielle. Et nous pensons qu’il faut prendre les mots « intelligent Agent » comme leur traduction littérale et ne pas voir d’Agent secret 007 derrière ces mots même si des Agents intelligents font certainement partie de l’arsenal de l’espionnage moderne.
Internet est défini comme inter-réseaux d’ordinateurs par A.Tanenbaum dans son livre [TAN].
Le plus grand et le plus connu étant Internet (avec un « I » majuscule) se basant sur la pile de protocole TCP/IP. Dans cette bibliographie nous nous intéresserons aux intranets et extranets (ensemble de réseaux reliés entre eux) et aux réseaux des réseaux (Internet). D’une façon plus générale, à la technologie internet.
Une application Agent intelligent sur internet est un programme utilisant les diverses fonctionnalités du réseau (son environnement) pour atteindre un but voulu par son utilisateur. Elle doit avoir au minimum les caractéristiques suivantes pour être reconnue comme un Agent intelligent : un haut degré d’autonomie, l’interactivité, la réactivité, la capacité d’apprendre, la capacité sociale.
Nous verrons dans la section suivante que d’autres caractéristiques peuvent se greffer à cette définition, pour que l’Agent puisse réaliser sa tâche.
1 -
Généralités
Nous définissons ici les caractéristiques minimum à propos d’un Agent, qui sont :
L’autonomie : L’Agent travaille sans intervention directe, jusqu'à un point défini par l’utilisateur. L’autonomie d’un Agent peut aller du simple lancement d’une sauvegarde la nuit, à la négociation du prix d’un produit choisi par son mandataire.
L’interactivité : L’Agent doit pouvoir exercer des actions sur son environnement et réciproquement. L’interactivité d’un Agent de sauvegarde sera sa possibilité de sauvegarder un certain nombre de fichiers par une action exercée au travers du système d’exploitation. Ce dernier pourra informer l’Agent d’une permission non accordée (exemple : un fichier dont l’utilisateur n’a pas de droit de lecture).
La réactivité : L’Agent percevra son environnement (qui pourra être l’utilisateur au travers une interface graphique, un ensemble d’Agents, …) en répondant dans les temps impartis aux changements qui surviennent sur cet environnement (exemple : un Agent de sauvegarde pourra faire sa tache à une heure donnée).
Un zoom sur
l’intelligence
Dans la section définition nous avons posé (en se basant sur les travaux de Caglayan et Nwana ) que l’intelligence était basée sur un agrégat de caractéristiques (la capacité d’apprendre, la capacité sociale et une haute autonomie) chacun pouvant avoir des degrés divers.
La capacité d’apprendre
Le petit Larousse définit « apprendre » (du latin appréhendée, saisir) comme le fait « d’acquérir la connaissance, l’information, l’habitude ». Un Agent aura la capacité d’apprendre si il sait acquérir de la connaissance, de l’information ou des habitudes.
Exemple : Un Agent grâce à sa capacité de réactivité, doit se déclencher à une certaine heure. Mais l’utilisateur l’arrête dans sa tache (qui pourrait être une sauvegarde) car il ralentit le travail de l’utilisateur. L’Agent va apprendre à différer son exécution pour éviter de gêner l’utilisateur.
La capacité sociale
Les Agents interagissent avec les autre Agents (et éventuellement des êtres humains) grâce à des langages de communication entre Agents. Cette capacité sera la base pour la coopération entre les Agents.
Exemple 1 : Notre Agent de sauvegarde rencontre un autre Agent de sauvegarde sur un réseau. Ces deux Agents peuvent se mettre d’accord pour se partager le travail afin que la tâche soit achevée plus vite.
Exemple 2 : L’Agent ne peut exécuter sa tâche pour des raisons techniques diverses (problèmes de droits d’accès, par exemple). L’Agent va communiquer se fait à l’utilisateur, en lui apportant la démarche à suivre dans un langage naturel compréhensible. L’utilisateur pourra ensuite, en utilisant le même langage, indiquer à l’Agent comment résoudre le problème.
Haut degré
d’autonomie
L’Agent fonctionne sans intervention directe humaine ou autre (autonomie) et en plus il a une forme de contrôle sur ses actions et sur leur état interne (haut degré).
Schéma de la représentation de l’intelligence pour un Agent
Un peu plus d’intelligence
La pro-activité est une caractéristique qui est intégrée dans les Agents hautement intelligents (très rares actuellement). Les Agents n’agissent pas seulement en réponse à leur environnement, mais ils sont capables d’avoir un comportement guidé par un but, en ayant la possibilité de prendre l’initiative.
Exemple : Un Agent réseau peut décider, de lui-même, pendant un temps où il est non actif, de faire des statistiques sur les routeurs pour améliorer son activité future.
Les caractéristiques suivantes peuvent être ajoutées aux caractéristiques de base pour permettre à l’Agent d’exécuter sa tâche. Il s’agit ici d’une liste non exhaustive, d’autres caractéristiques peuvent s’ajouter et se combiner.
Coordinatif
L’Agent est capable de coordonner ses actions par rapport à un utilisateur ou un autre Agent.
Exemple : Un Agent de sauvegarde sauve les données qui viennent d’être mises à jour par un utilisateur ou par un autre Agent.
Compétitif
L’Agent est capable d’agir dans un environnement où d’autres Agents interviennent. Le but est le même pour tous les Agents présents, mais un seul l’atteindra. Les autres échoueront et, forcément, tous les coups sont permis.
Exemple : Un Agent commercial peut chercher les meilleurs prix et les meilleurs services pour un produit donné. En négociant avec les fournisseurs, d’une manière plus rapide et plus optimale qu’un autre Agent ou utilisateur. Un Agent très compétitif pourra induire ses « adversaires » sur de fausses pistes.
Afin d’éclaircir la définition de mobilité et dissiper nombre de confusions, nous devons prendre en compte deux types de mobilités :
· Mobilité relative, ou par requêtes :
Dans ce cas il n’y a pas un réel déplacement de l’Agent. Celui-ci lance une
succession de requêtes à destination de différents serveurs. C’est le cas des
Agents de recherche, tel que Copernic [COP], qui interroge différents moteurs
de recherche afin de fournir à son utilisateur une synthèse des résultats.
· Mobilité réelle de l’Agent :
Le processus Agent se déplace d’un serveur à un autre, sur le réseau. Le code de l’objet est transporté et ses données, aussi. Ensuite, il continue son exécution sur la nouvelle machine.
Exemple : Un Agent de sauvegarde peut se déplacer sur plusieurs serveurs dans le but de faire des restaurations de fichiers.
Quand nous parlerons d’Agent mobile, c’est ce dernier cas qui sera pris en compte.
La technologie Agent est bouillonnante. De très nombreux acteurs interviennent sur le sujet : universités, centres de recherche, sociétés privées et leur classification des Agents dépends de leur utilisation. L’importance de cette classification est qu’elle permet de donner des attributs aux Agents.
On retiendra celle de Hyacinth S Nwana du laboratoire de British Telecom (1996) [NWA] qui distingue 4 types d’Agents : les Agents d’interface, les Agents collaboratifs, les Agents collaboratifs capable d’apprentissage et les Agents réellement intelligents (smart).
La société Reticular System Inc qui produit le ToolKit AgentBuilder a aussi sa classification [RET]. Elle s’appuie sur celle de Nwana mais y ajoute des Agents mobiles, des Agents d’information et des systèmes d’Agents hétérogènes.
Carlo Revelli [REV-P91] reprends une classification légèrement différente. Alper Caglayan et Colin Harrisson [CAG-P24] en décrivent une autre.
Mais depuis, de nouveaux types d’Agents sont apparus et ces classifications ne suffisent plus. Aussi, nous allons reprendre celle de l’OMG [OMG-AWG] qui date de 1999 :
· Les Agents intelligents,
· Les Agents mobiles,
· Les Agents d’information,
· Les Agents d’interface utilisateur,
· Les Agents commissionnaires.
Et, pour compliquer un peu plus, chaque type d’Agent peut se diviser en plusieurs sous-types.
Quand un Agent a une certaine indépendance d’un contrôle extérieur, il est considéré comme autonome (voir la définition de l’autonomie, ci-dessus).
Ces Agents ont la capacité de communiquer avec leur environnement et avec d’autres entités. Ils échangent leurs communications en utilisant des protocoles (KQML, KIF). Certains utilisent des ontologies pour communiquer avec leur utilisateur (FIPA) ou avec d’autres Agents (voir la définition de l’interactivité, ci-dessus).
Un Agent capable de répondre à d’autres Agents ou à son environnement est considéré comme adaptatif (voir la définition de la réactivité, ci-dessus). La capacité d’apprendre et d’évoluer fait partie des Agents hautement adaptatifs.
Une liste des Agents actuellement disponibles, ainsi que les outils de création d’Agents, existe. Elle est extraite du site de AgentBuilder [RET]. En effet, cette société commerciale présente un tableau avec un certain nombre d’acteurs du monde Agent et leurs réalisations. Provenant d’une source commerciale, il faut s’attendre à ce que cette liste ne soit pas exhaustive. Cependant, il faut noter cet effort et encourager l’esprit.
Nous présentons cette liste dans l’annexe A : Liste des Agents.
On peut dire que la notion d’intelligence pour les Agents est complètement différente de celle des humains. Les Agents ne sont pas là pour supplanter les humains, mais pour les assister. Un Agent intelligent doit avoir de la connaissance et doit pouvoir agir dessus. Il peut examiner ses objectifs, nommer ses intentions, planifier ses actions et éventuellement, agir sur ses plans. De plus , il doit être capable d’interagir avec d’autres Agents.
Cela ressemble beaucoup à un comportement humain. Il ne faut pas être surpris, les chercheurs utilisent leur connaissance de l’intelligence humaine comme modèle de l’intelligence des Agents.
Les Agents mobiles se déplacent d’une machine à l’autre. Pour migrer, un Agent mobile transfère son code et ses données sur le nouveau site puis continue son exécution sur ce site là. A l’issue de la migration, le processus de la machine initiale est détruit par une commande du nouveau processus. L’intérêt de ces Agents concerne les recherches dans beaucoup de données sur des sites éloignés. Par contre, les Agents mobiles entraînent des problèmes de sécurité pour le site hébergeur, mais aussi pour l’Agent. Ils entraînent des problèmes de consommation de ressources et de dimensionnement sur la machine hôte.
Quelques Agents
mobiles
Des éditeurs ont créé des Agents mobiles qui tournent dans des environnements spécialisés.
GRASSHOPPER, IKV++ [GRA]
GRASSHOPPER est produit par IKV++, depuis 1998. Les Agents mobiles servent à la gestion d’un réseau intelligent (Intelligent Network). Utilise le standard MASIF de l’OMG [OMG-MAF].
GOSSIP, TRYLLIAN [GOS]
La société TRYLLIAN vient de rendre disponible le ToolKit GOSSIP pour paramètrer des Agents mobiles, indépendamment de leur utilisation future (monitorer un réseau, rechercher les meilleurs affaires du e-commerce, rechercher des informations, …). L’utilisateur détermine l’action de l’Agent. Ce logiciel est disponible gratuitement en téléchargement sur le site.
Les « interest matching Agents » sont probablement les Agents les plus utilisés et la plupart des utilisateurs ne savent pas qu’ils les utilisent. On retrouve ces Agents sur les sites WEB commerciaux. Ils y proposent des recommandations : « Vous avez aimé le livre « Les Agents, applications bureautiques, internet et intranet » de Caglayan [CAG], vous aimerez certainement le livre de Matthias Klusch « Intelligent Information Agents » [KLU] ».
Ces Agents, basés sur les travaux de Patti Maes au MIT Media Laboratory [MIT] puis à Firefly, observent des comportements similaires et des habitudes pour faire leurs recommandations.
La quantité d’information disponible restreint la capacité de la plupart des utilisateurs de retrouver l’information utile. Les Agents de recherche disposent de la connaissance de diverses sources d’information. Cette connaissance inclut le type des informations disponibles à chaque source, comment accéder à ces données et leur fiabilité.
Une autre tâche commune des Agents. Les Agents de filtrage d’information essaient de résoudre le problème de la surcharge d’information en limitant et en triant les informations arrivant à un utilisateur. L’idée de base est de développer un substitut en-ligne qui connaît suffisamment les goûts de son utilisateur pour choisir les documents intéressants. Ces Agents sont parfois incorporés à des Agents de recherche pour éviter des résultats de recherche trop importants. Les Agents de filtrage d’information comportent des mécanismes d’apprentissage. Cela leur permet de s’adapter aux besoins de leur utilisateur.
Des tâches sont dépendantes de la notification du changement de certaines données. La veille technologique utilise ce genre d’outils pour suivre les changements sur les sites WEB choisis. Un planificateur de logistique du transport aérien peut être informé des changements dans les conditions météorologiques et dérouter ses avions en conséquence.
Les Agents de suivi de l’information permettent de consulter des sources de données diverses et de faire un suivi permanent des changements apportés. Ces Agents pourrait être mobiles pour pouvoir se déplacer de site en site ou pour se rendre dans des endroits plus difficilement accessible.
Le paysage de la gestion des données est rempli d’une multitude de systèmes. La plupart ne se parlent pas. Les Agents peuvent être employés comme des médiateurs entre toutes ses sources de données, fournissant les mécanismes leur permettant d’inter-opérer. Ces mécanismes peuvent être un protocole de communication et des ontologies décrivant les données contenues dans ces sources.
Un Agent d’interface est un programme qui assiste l’utilisateur dans la mise en œuvre d’un système ou d’un logiciel (Voir les Agents office de Microsoft). Dans le futur, ces Agents pourront être étendus au monde du WEB, pour assister l’utilisateur.
Tous ceux qui ont fait l'expérience de rechercher un article sur le WEB (exemple un CD de musique) dans le but de comparer les offres ont mesuré la difficulté et la longueur de l'opération. Il est nécessaire de trouver des sites WEB spécialisés dans la vente de disques, de déterminer si le titre recherché y est référencé, d'en trouver le prix et ceci pour chaque site WEB. Toute personne ayant tenté une telle opération finit par le regretter...
Or, c'est typiquement le genre de problèmes qu'un Agent intelligent peut prendre en charge à la place d'un utilisateur.
Ces Agents pourront donc vous renseigner :
· sur la disponibilité d'un produit en menant une recherche par marque ou par catégorie (produits + accessoires),
· sur l'identification des distributeurs : localisation d'un distributeur précis, liste intégrale ou sélective de distributeurs (en fonction des services qu'ils offrent : garantie, facilité de paiement,...),
· en traitant les informations collectées, par exemple grâce à des tableaux comparatifs des offres présentées sur divers critères (prix, services, avis d'autres consommateurs,...).
· en établissant une pré-sélection automatique d'articles en fonction des préférences du consommateur (priorité au rapport qualité - prix, au service, aux avis des
autres consommateurs,...)
· en réalisant la transaction :
Ø de façon automatique (achat répétitif d'un panier de produits/alimentation, achat dès qu'un modèle est en solde),
Ø ou semi-automatique : recommandation/suggestion, accord de transactions automatiques (ordre d'achat, paiement, réception de la facture et gestion simplifiée de la comptabilité)
Bénéfices pour le consommateur : gain de temps, analyse d'une offre commerciale plus étendue, transparence des marchés. Soutien d'un Agent qui connaît de mieux en mieux ses goûts.
Bénéfices pour le distributeur : localisation plus facile des boutiques, augmentation des ventes pour celles qui parviennent à analyser la demande.
Quelques Agents d’achat [REV – P120] :
BargainFinder de Andersen Consulting,
Jango intégré dans Excite,
Firefly créé par Pattie Maes et intégré dans Yahoo.
Les Agents solos ont très peu d’interaction avec d’autres Agents et sont restreints par leurs propres limites. Les systèmes multi-Agents (MAS : Multi Agent System) peuvent profiter des divers rôles de chacun des Agents du système.
Un Agent qui fait tout serait très difficile à créer, à debugger, à maintenir et il aurait des temps de réponses assez faible. Découper les fonctionnalités parmi plusieurs sortes d’Agents offre une meilleure modularité, flexibilité et extensibilité.
Les Agents d’un système multi-Agents peuvent se « partager » des tâches qui seront exécutées en parallèle.
Les Agents solos sont plus faciles à construire que les MAS, car les développeurs n’ont pas à se préoccuper de coopération et de coordination. Mais l’industrie aura besoin de ces qualités et donc des systèmes multi-Agents [ALA].
Nous retrouvons les acteurs coutumiers des avancées dans le monde de l’informatique : les universités, les centres de recherche et les sociétés privées. En tant que « normalisateur », des organisations de standardisation. Et, en tant que bailleur de fonds, des organismes gouvernementaux des USA, mais aussi de l’Europe.
Nous en faisons une liste succincte. Désolé pour les manquants, nous n’avons pas détecté tous le monde pendant nos recherches.
Dans ce paragraphe, nous présentons les principaux acteurs universitaires du monde des Agents. Une liste plus complète se trouve dans l’annexe C – Les universitaires.
Joachim Baumann Université
de Stuttgart, Germany.
Sonia Bergamaschi Université de Bologne, Italy.
Jacques Ferber Université de Montpellier II, France.
Tim Finin Université du Maryland – Comté de Baltimore, USA.
Robert Gray College de Dartmouth, USA.
Matthias Klusch Université de Chemnitz, Germany.
David Kotz College de Dartmouth, USA.
Patty Maes MIT,
USA.
Katia Sycara Université de Carnegie Mellon, USA.
Les grandes corporations et groupes de Télécommunication ont mis en place des centres de recherche sur la technologie Agent. On retrouve :
· IBM Japan, qui fabrique les aglets [IBM-JAP].
· Mitsibushi, avec le MEITCA (Mitsibushi Electric Information Technology Center American) produit l’Agent Concordia [MEI].
· Toshiba Corporation, avec le laboratoire « Systems and Software Research », produit l’Agent Bee-gent [TOS].
· Les laboratoires de British Telecommunication produisent l’Agent Zeus [BTL].
Et voici une liste des personnes actives dans la branche :
Stefan Bussmann Daimler-Chrysler,
Germany.
Klaus Fischer DFKI,
Germany.
Keith Golden NASA
Ames Res. Ctr., USA.
Afsaneh Haddadi Daimler-Chrysler, Germany.
Marc Huber Intelligent
Reasoning Systems, USA.
Joerg Mueller Siemens, Germany.
Hyacinth S Nwana British
Telecom Labs, UK.
Onn Shehory IBM Haifa Res. Labs, Israel.
Wayne Wobcke British Telecom Labs, UK.
On retrouve un grand nombre de sociétés privées. Nous n’en citerons que quelques unes, d’autres étant citées ailleurs dans le document, la plupart seront malheureusement « oubliées ».
Reticular Systems Inc avec AgentBuilder [RET].
Agent Oriented Software Pty. Ltd avec l’Agent JACK [JAC].
ObjectSpace avec Voyager [OBJ].
L’Object Management Group est présent sur plusieurs volets de la technologie Agent. Avec le Agent Working Group, il vient d’émettre une série de RFP (Request For Proposal) et un « green paper » dans le but de fournir des suggestions pour la standardisation de certains domaines de la technologie Agent [OMG-AWG]. Un autre travail de l’OMG a été le « standard » MASIF (Mobile Agent System Interoperability Facility) [OMG-MAF]. Le système GRASSHOPPER a été développé en utilisant cette recommandation [GRA].
Un autre acteur est le FIPA (Foundation for Intelligent Physical Agent). Cet organisme, basé à Genève, est actif depuis 3 ans et demi, organise 4 congrès annuellement et a produit un grand nombre de documents. Ces recommandations portent sur la communication des Agents, la gestion des Agents, l’interaction homme/Agent, …[FIP]
Dans les organismes gouvernementaux, nous retrouvons le désormais célèbre mécène de Internet, le DARPA. Toutes les universités américaines, actives dans la technologie Agent, ont des contrats avec lui (Voir les sites des universités).
Un nouvel acteur américain est le MITRE. Cet organisme fédéral sert à financer la recherche universitaire dans un certain nombre de domaines [MIR].
La Communauté Européenne finance la recherche grâce au projet ESPRIT. Une section est réservée à la technologie Agent : AgentLink. Elle produit un journal trimestriel et organise des conférences [AGL].
Un nouvel acteur est CLIMATE (Cluster for Intelligent Mobile Agents for Telecommunication Environments). Actif depuis Juin 1998, il reprend certaines recommandations de l’OMG et du FIPA. C’est aussi, un ensemble de projets financés par la Communauté Européenne [CLI].
Dans cette partie de généralités, nous avons vu la définition de termes et de notions, les caractéristiques des Agents et les types d’Agents. Et nous avons vu quelques uns des acteurs qui interviennent sur le sujet.
La prochaine partie nous présentera la façon dont est mis en œuvre cette technologie, à l’aide de quelques exemples.
2 - Mise en œuvre
Cette section à pour but d’expliquer les principes de fonctionnement (la mécanique) des Agents et de faire comprendre aux lecteurs que les Agents intelligents ou mobiles n’ont rien de « magique » [CAG].
Dans la section définition, nous avons vu qu’un Agent mobile se déplace de machine en machine. Pour que cela soit possible, il faut que les données envoyées sur le support de communication (« les signaux électriques ») soient reconnues comme « un programme Agent » et non plus seulement comme de « simple données ».
Pour permette cela, il faut que la machine qui reçoit l’Agent, possède un programme tournant en tâche de fond (un démon), qui permet de reconnaître un programme Agent. Ce démon est appelé un serveur d’Agent.
De plus, le serveur d’Agent doit avoir la possibilité d’exécuter le « programme Agent », c’est à dire de transformer le programme Agent en un « processus Agent », quelque soit le type de la plate-forme (système d’exploitation).
Dans la majorité des cas, la résolution de ce problème passe par la mise en place d’une machine virtuelle. Cette dernière est une pseudo machine (logiciel), développée pour le maximum de plates-formes et permettant de rendre invisible les spécificités d’un système donné, pour les programmes s’exécutant sur la machine virtuelle.
Support Physique
Il faut pour finir, rajouter à tout cela un protocole (de la couche application) permettant le dialogue entre les deux serveurs d’Agent pour la transmission des « programmes Agents ». Un tel protocole sera étudié dans la suite de la bibliographie (le protocole ATP).
Nous avons posé dans la section définition qu’un agent était intelligent, si il avait l’ensemble de caractéristiques suivantes : une capacité sociale, une capacité à apprendre et un haut degré d’autonomie.
Pour permette cela, il faut intégrer au programme agent les modules suivant :
· Un module permettant de mémoriser le savoir de l’agent qui sera le plus souvent fait par la réalisation d’un système de base de données (SGBD). Ce module sera nommé « base de connaissance ».
· Un module permettant de connaître l’ontologie de la « base de connaissance ». Il sera appelé « Le contrôleur d’accès » qui peut reposer sur un SGBD, dit « intelligent » .
· Un module permettant à l’agent d’avoir une vision de son environnement, « l’interface de l’agent ».
· Un module permettant la génération de nouvelles connaissances, il sera nommé « moteur d’apprentissage ».
· Un module permettant le raisonnement de l’agent, il sera nommé « moteur de raisonnement ».
Ces modules devrons être agencés de telle façon que le flux d’information qu’ils génèrent, permette de caractériser le concept d’intelligence. Un des modèles le plus souvent rencontré est représenté par le schéma suivant :
Schématisation du mécanisme de l’intelligence chez un agent
Nous pouvons dès lors, faire la distinction entre quatre groupes [CAG] :
· Le contenu représente les données employées par les mécanismes dans le raisonnement de l’apprentissage (représenté sur le schéma par la base de connaissance) .
· Le mécanismes de l’agent contenant les moteurs d’apprentissage et de réflexion .
· L’accès qui permet de percevoir le contenu des connaissances de l’agent.
· L’interface permettant une perception de l’environnement de l’agent.
Les trois premiers groupes reposent techniquement, dans la plupart des cas, sur un moteur d’inférence. Ce dernier contient : les domaines et les relations ente les « objets » utilisés (« l’accès »), les faits (« Le contenu »), ainsi que des règles (« les mécanismes »). L’exemple de l’annexe E – Programme Prolog, permettra de mieux comprendre.
Quand à l’interface, elle repose le plus souvent sur une application de type « middleware » permettant d’agir et de prendre des informations sur l’environnement de l’Agent.
Comme on a pu le constater, le fonctionnement de la mobilité et de l’intelligence repose sur des idées simples, mais souvent insuffisantes pour donner des solutions à tous les problèmes que l’homme voudrait pouvoir résoudre avec la technologie Agent.
L’objectif de cette section est de présenter les différents langages de programmation utilisés dans la conceptions des Agents. Le but n’est pas de faire un cours complet sur les langages mais de permettre au lecteur de pouvoir comprendre la philosophie de la programmation orientée Agent.
Quelque mots sur les L.O.O (Langages Orienté Objet).
La programmation orientée objet (en abrégé P.O.O) à pour objectif de faciliter l’activité de programmation, notamment en permettant de développer des composants logiciel réutilisable.
Elle s’appuie sur l’objet, l’objet est un ensemble regroupant des traitements (méthodes), et des donnés (propriétés). L’objet permet aux développeurs de penser le problème, non plus en terme uniquement de manipulations de « nombres », mais en terme « d’énoncé» du problème. Dans un L.O.O, le « plan » d’un objet est représenté sous forme d’une classe (contenant des méthodes et des propriétés), plusieurs objets peuvent être créés (instanciés) en s’appuyant sur la même classe. De plus la L.O.O fait appel à des notions tel que l'encapsulation, l’héritage, le polymorphisme.... , qui sont inconnues de la plupart des langages traditionnel tels que le C ou Pascal.
Tout ceci confère aux L.O.O un bon avantage dans les langages de création d’Agent. [CAG]
Caractéristiques du Langage Java
Le langage Java (terme argotique pour dire café) a été créé par la société Sun Microsystems [SUN] il y a 5 ans. Le principal objectif de Java est d’augmenter la productivité des programmeurs. Pour cela il permet de :
· Le « Write once, run everywhere », « écrire une fois, utiliser partout » ; pour ne pas être limité aux développements pour une seul plate forme (un programme écrit en java tournera de la même façon sur MS Windows ou sur Unix).
· De plus, il y a de nombreuses fonctionnalités (méthodes) liées aux mondes des réseaux.
· Il est orienté objet, pour faciliter la réutilisation et la maintenance des programmes.
· Pour finir, le minimum nécessaire pour développer une application en langage Java est disponible gratuitement sur le site de Sun Microsystems [SUN].
Mécanisme général du langage Java
Pour qu’un programme écrit en langage java puisse être exécuté sur plusieurs plates-formes, il est dans un 1er temps compilé en bytecode. Le bytecode est un code pouvant être interprété par une machine virtuel, la JVM (Java Virtual Machine). Pour chaque plate-forme, une JVM à déjà été écrite par la société Sun Microsystems [SUN].
Figure : le
mécanisme du langage java
Comme on peut s’en douter, l’interprétation du bytecode par la machine virtuel (JVM) entraîne un ralentissement du programme. C’est pour cela qu’il est possible pour l’utilisateur du programme java d’utiliser un compilateur JIT (Just In Time). Celui-ci permettra à la machine virtuelle de compiler le programme bytecode en code natif du CPU (langage machine) avant son exécution. Le programme ne sera plus interprété par la JVM mais par le processeur de la machine grâce à une compilation qui aura eu lieu « juste à temps » (JIT).
Java mode d’emploi
Pour programmer en Java, il faut :
· un éditeur de texte : pour saisir le code Java.
· Le JDK (Java Development Kit) : Ce kit (téléchargeable) sur le site de Sun Microsystems [SUN] contient javac (le compilateur de bytecode) , java (l’interpréteur de bytecode) et de la documentation.
Ce qui précède est suffisant pour développer une application en Java. Si vous souhaitez aussi la déployer, il faudra y ajouter le JRE (Java Runtime Environnement) qui contient lui aussi un interpréteur de bytecode, un compilateur JIT. C’est la JRE qui sera fourni à l’utilisateur final avec votre programme en java.
Les packages Java
Pour les développeurs, Java offre la possibilité de regrouper les objets créés (plus exactement les classes des objets) dans un même fichier. Ce dernier est appelé un package, ceci permet de réutiliser au maximum le code déjà écrit.
Critique du langage Java
Une des plus importantes critiques qu’on pourrait faire à Java est son manque de compatibilité entre les versions, malgré les efforts de Sun Microsystems [SUN] pour l’assurer.
Java et les Agents
Comme nous l’avons vu dans la section à propos des mécanismes, un Agent mobile à besoin d’une machine virtuel pour fonctionner or Java en possède une. De plus le langage Java est sécurisé car c’est la JVM qui vérifie au moment de l’exécution, la fiabilité du code.
Exemple : Un accès à un index supérieur à celui du format d’un tableau ne causera pas de « plantage » comme en C, car la JVM surveille ce problème.
Pour finir Java est orienté objet et tout ceci confère à Java une bonne place pour la construction d’Agents.
Le langage C
Ce langage a été créé en 1972 par Denis Ritchie dans le but d’écrire le système d’exploitation (UNIX). Son succès international a amené l’ANSI (American National Standard Institute) à définir un « standard » (on le qualifie souvent de « C ANSI »).
Le langage C présente les caractéristiques suivantes :
· Le suivi des règles de la programmation structurée,
· Un langage orienté système, c’est à dire qu’il est le langage le plus proche du « raisonnement » d’un ordinateur, après l’assembleur,
· Le langage C est un langage compilé, c’est à dire que la totalité du code source est traduit en langage machine, avant exécution,
· Pour finir le langage C est connu d’un grand nombre de développeurs.
Critique du langage C
Un gros programme écrit en C est difficile à maintenir. De plus, ne s’exécutant pas sur une machine virtuel, celui-ci doit être recompilé pour chaque plate-forme. Par contre, les grands avantages du C sont, qu’il existe quasiment un compilateur C pour chaque type de plate-forme et qu’il est toujours très employé.
Le langage C et les Agents :
Le langage C étant un langage système tout lui est possible. Ce qui fournit aux Agents écrits en C, une très grande puissance et une vitesse d’exécution inégalée. Par contre, cet avantage entraîne deux problèmes :
· Le langage C n’est pas sécurisé, ce qui peut entraîner, un « plantage » des machines qui exécuteraient un processus Agent basé sur ce langage,
· Le langage C devant être compilé avant son exécution, celui ci permet difficilement à première vue de créer un Agent mobile. Ce problème est résolu par certains outils de création d’Agent, par la diffusion du code source du programme Agent et d’un script de « commande » (pas uniquement un makefile). Si la plate-forme ne correspond pas à l’original, alors le programme C est recompilé pour créer un Agent pouvant fonctionner sur cette nouvelle plate forme [CAG].
Le langage C++
Ce langage a été créé à partir des années 1980, par B. Stroustrup (AT&T). Il avait comme objectifs d’ajouter au langage C des spécifications supplémentaires lui permettant d’appliquer les concepts de la P.O.O (programmation orienté objet).
Le langage C++ présente les caractéristiques suivantes :
· Langage compilé,
· Langage orienté objet (sauf pour les puristes de l’objet).
Critique du langage C++
Malgré ces caractéristiques objet, un programme écrit en C++ est difficilement maintenable, ressemblant très rapidement à « une usine à gaz ». Par contre un grand nombre des avantages du langage C s’y retrouvent, avec en plus, la puissance d’un L.O.O.
Les
Agents et le langage C++
La puissance du C++ est le plus souvent utilisé pour créer des Agents avec un haut degré d’intelligence [UMP] voir le site de UMPRS [UMP] où les sources d’un outil Agent orienté Intelligence Artificielle écrit en C++ sont téléchargeables.
Python
Langage créé il y a une dizaine d’années. Python offre de nombreux avantages tels que la possibilité d’être compilé ou interprété et d’être orienté objet. De plus, il s’apprend facilement et la communauté de développeurs de ce langage libre est très active [PYT]. Il faut aller voir le site de Olivier Berger, auteur de la version française de « Learning Python » [OLB]. Ce langage est annoncé [L&S] comme ayant un avenir radieux. De plus, il a toutes les caractéristiques et la puissance d’un langage pouvant créer des Agents.
PHP
PHP est un langage script s’exécutant sur le serveur, comparable dans ces grandes lignes au Javascript serveur. Il permet notamment d’interagir entre des SGBDR situés sur un serveur et un poste client équipé d’un navigateur. Cela lui donne de grandes capacités pour la création d’Agents en l’associant à d’autres langages tels que le C ou PROLOG.
L’objectif de cette partie est de faire un point sur les principaux outils existant pour la création d’Agents. Voir dans l’annexe A, la liste des Agents.
En 1996 Big Blue (IBM) met à disposition « Aglets Worbench » qui regroupe une librairie sous forme d’un package Java, ainsi qu’un serveur d’aglets (Tahiti) [IBM-JAP]. « Aglets Workbench » sera renommé en 1998, ASDK (Aglets Software Developement Kit). La ASDK est destiné à faciliter la création d’Agent mobile.
Aglets vient des mots Agent et Applet. Quand nous parlons de serveur d’Aglets, ceci est équivalent à un serveur d’Agent pour ce système.
Actuellement, IBM met à disposition (gratuitement) sur son site deux version ASDK, la 1.0.3 et la version 1.1 Beta 2 (datant du 20/02/1999). Ces deux versions ne peuvent fonctionner qu’avec la JDK 1.1 mais surtout pas avec la JDK 1.2 (Java 2). La version 1.0.3 est non limitée dans le temps. La version 1.1 Beta 2 doit être réinstallée après un certain temps d’utilisation (limitation dans le temps).
Pour le fonctionnement des aglets, la pile de protocoles TCP/IP doit être installée dans un premier temps.
Puis, après avoir téléchargé la ASDK et une version de la JDK 1.1 (dans nos test nous avons utilisé la version 1.1.8), il faut initialiser certaines variables d’environnement. Elles sont nécessaires pour le fonctionnement du serveur d’aglets (le démon Tahiti) et de la machine virtuel Java (tel que CLASSPATH, Aglet_Home etc…).
Voir les sites de Sun [SUN] et d’IBM [IBM-JAP] pour de plus amples détails.
Le lancement de Tahiti ce fait par l’exécution du fichier de commandes « agletsd.bat » (sous plate-forme Windows). Ce dernier exécute le démon Tahiti (le serveur) ainsi qu’un Viewer d’aglet qui porte le même nom.
Fig :
Copie écran du viewer d’aglet : Tahiti
C’est grâce à ce dernier que nous pouvons faire des opération précises sur les Aglets : les exécuter, les détruire, les envoyer sur un serveur distant, etc.
Au lancement de Tahiti, le serveur écoute sur le port 434 par défaut. Il est possible de choisir un autre port en spécifiant le numéro du port sur la ligne de commande, au lancement de Tahiti.
Exemple : agletsd –port 500 /*le numéro du port d ‘écoute est 500*/
Tahiti permet aussi de définir la confiance qu’on met dans un Agent.
Exemple : On peut spécifier qu’un Agent nommé « AGENT-TOTO » pourra avoir accès à un répertoire ou à une ressource réseau spécifiques.
Les Aglets reposant sur des packages, la connaissance du langage Java est nécessaire. Ensuite il « suffit » d’utiliser les objets qui sont disponibles grâce à ce package (méthodes pour se déplacer, pour se cloner, etc). Pour finir, on charge notre Aglet sur le serveur d’Aglet .
Un listing complet d’un exemple d’Aglet commenté (écrit par IBM) est donné sur le site [IBM-JAP]. Cet Aglet se déplace sur un autre serveur en affichant un message défini par l’utilisateur (par défaut Hello World ). Puis il revient sur son serveur d’origine en affichant « I’m come back ». Pour finir, il se s’arrête.
C’est un processus qui voyage et pas seulement un échange de signaux entre serveurs. Cette mobilité repose pour les Aglets sur le protocole ATP (Agent Transfert Protocol) qui sera exposé plus loin dans cette bibliographie.
TELESCRIPT est un environnement pour le développement de sociétés d’Agents créé par General Magic basés sur deux concepts clés [LOR]:
· les places sont des lieux virtuels occupés par les Agents,
· les Agents :
ce sont des processus mobiles. Ils sont capables de se déplacer d'une place à une autre, auquel cas leur programme et leur état sont codés puis transmis sur le réseau à une autre place où l'exécution continue. Ils sont capables de communiquer les uns avec les autres : si ils occupent différentes places, ils peuvent se connecter à travers le réseau, sinon, ils peuvent se rencontrer.
Quatre composants ont été développés pour supporter la technologie TELESCRIPT.
· Le langage TELESCRIPT : il est conçu pour exécuter des tâches de communication complexes comme la navigation, le transport, l'authentification, le contrôle d'accès, …
· Le moteur TELESCRIPT: il agit comme un interpréteur du langage TELESCRIPT, maintient les places, ordonnance l'exécution des Agents, supervise la communication et le transport des Agents et fournit une interface avec d'autres applications.
· L'ensemble du protocole TELESCRIPT: ces protocoles gèrent le codage et le décodage des Agents pour permettre le transport entre les places.
· Un ensemble d’outils logiciels pour le développement d’applications TELESCRIPT.
Jusqu'à présent tous les outils nécessitaient une bonne connaissance d’un langage de programmation. Dans la plupart des cas, il s’agissait de Java. AgentBuilder est une exception à cette règle. AgentBuilder est créé par la société Reticular Systems Inc [RET], qui présente son outil comme offrant la possibilité de construire intelligemment, rapidement et à bon marché un Agent.
Cette société propose deux versions de son produit, de la moins complète à la plus complète (AgentBuilder Lite et AgentBuilder Pro) dont les prix sont compris entre 510$ et 4990$.
Les Agents sont développés par l’intermédiaire d’une interface conviviale. Cette technologie est toujours basée sur la JVM (comme pour Voyager), mais permet grâce à son approche, de se concentrer plus sur les fonctionnalités de l’Agent que sur le codage.
AgentBuilder : Des interfaces conviviales
Pour mieux présenter la philosophie de ce ToolKit, voici une liste des principaux composants inclus dans la version Pro d’AgentBuilder :
· Ontology Manager : Il permet de modéliser les connaissances d’un Agent intelligent,
· Agency Manager : Permet de créer et de manager les applications Agents,
· Agency Viewer : Permet de voir, en temps réel, le comportement des Agents lors de leurs exécution,
· Role Editor : Permet de formaliser les règles que suivront les Agents créés,
· Protocol Editors : Permet de spécifier ou de créer des protocoles de communication inter-Agent,
· Agency debbuging support : Permet d’optimiser la phase de correction d’erreur, lors du développement d’un Agent.
Et la liste est loin d’être finie …
Les Agents développés avec AgentBuilder peuvent s’exécuter sur des plates-formes très diverses comme par exemple : Solaris [SUN], MS Windows NT/ 98/95, IRIX (Silicon Graphics) et Linux.
Comme on peut le constater, il est vrai que l’utilisation de l’outil respecte ce qu’annonce AgentBuilder (« Smarter, faster, and Cheaper ») sauf peut être pour le dernier point (« Cheaper »). Surtout si on souhaite que de très nombreux Agents fonctionnent en même temps. En effet, tous les Agents créés sont soumis à une licence d’utilisation (un Agent = une licence). Plus exactement, il faut un « Run-Time-Engine » pour faire fonctionner un Agent (pour indication, un pack de 10 « Run-Time-Engine » coûte 49$).
Reticular Systems Inc est si sûre de son produit, qu’elle fournit sur son site WEB une liste exhaustive et mise à jour régulièrement, des produits de ses concurrents. De plus, des versions d ‘évaluation de ses produits son disponibles sur son site [RET].
Voyager est un outil commercialisé par la société ObjectSpace [OBJ], créée en 1990. Voyager est basé sur l’environnement Java (Java 2). Il est défini comme étant un ORB (Object Request Broker) permettant de créer des applications Java distribuées. Le principe de mise en place pour un Agent créé par Voyager est similaire à celui des Aglets d’IBM.
Dans Voyager, un Agent est une classe qui hérite de la classe Agent de l’API Voyager. Celui-ci est identifiable par son nom et par une référence virtuelle. Les Agents peuvent communiquer grâce à différents types de messages :
· Messages synchrones : c’est le type de message par défaut, l’Agent attend une réponse avant de continuer sa tâche,
· Messages à sens unique : ce sont des messages envoyés une seule fois et qui n’ont pas de valeur de retour,
· Message Asynchrones (futurs messages) : permettent de ne pas interrompre l’exécution de l’Agent,
· Messages multicast : permettent d’envoyer un message à plusieurs objets Voyager à la fois qui appartiennent à un même groupe (Space).
A toute ces fonctionnalités de messages se rajoute une méthode permettant de migrer (moveTo()) vers un site distant, mais aussi vers un autre Agent de type Voyager.
Un exemple complet d’un programme écrit en Java représentant « un chat et une souris » se pourchassant sur un réseau, est donné dans l’annexe B – Le chat et la souris, ce programme est basé sur la fonctionnalité de migration vers un autre Agent, offerte par Voyager.
Pour pouvoir faire fonctionner Voyager, il vous faut télécharger le package com.objectspace.voyager à partir du site de Objectspace [OBJ]. Puis installer le serveur d’Agents (VAS), lui aussi fourni sur le site. L’utilisation des différents outils fournis par Objectspace est gratuite dans le cadre d’une évaluation.
La société Objectspace offre de nombreux outils pour la création d’Agents et leur optimisation (tel qu’un gestionnaire de sécurité appelé VoyagerSecurityManager). De plus, contrairement aux Aglets d’IBM, Voyager Application Server (VAS) (le serveur d’Agent), est beaucoup plus simple à installer. Tout ce fait par l’intermédiaire d’un « setup ».
Pour finir, Voyager supporte toute les technologies récentes liées à l’utilisation d’objets répartis (Corba, DCOM, RMI).
Voyager nous a donné l’image d’un produit fini. Cette impression est partagée par Novell qui l’utilise pour l’aide à la conception de son dictionnaire de partages de ressources réseaux NDS.
Les Agents mobiles sont des programmes pouvant êtres transférés sur des hôtes distants afin d’exécuter différentes tâches pour leurs utilisateurs.
ATP ( Agent Tranfert Protocol ), est un protocole de niveau application couche 7 du modèle OSI . Il permet le transfert des Agents mobiles entre plusieurs ordinateurs.
Aujourd’hui, on trouve différents langages et outils permettant de programmer des Agents mobiles avec des plates-formes spécifiques (consistant généralement en une machine virtuelle et un ensemble de bibliothèques), ATP offre une possibilité commune pour le transfert des Agents quelque soit leur type et les outils utilisés.
Les informations de cette partie
sont reprises du site d’IBM [IBM-JAP].
Le protocole ATP est basé sur le paradigme de Question/Réponse entre service d’Agents.
Toute plate-forme d’Agents pourra utiliser le protocole ATP dés lors que la machine virtuelle qui les héberge, comporte un service de transport ATP.
Le service de l’Agent A établit une connexion avec le service de l’Agent B, envoie une requête puis attend la réponse.
Dispatch : Requête de dépêche : - source à destination – accepter mon Agent.
Un service d’Agents A établit une connexion avec un service d’Agents B afin de lui demander d'accepter un Agent. Si le service B accepte, il reconstruit l’Agent contenu dans le corps de la requête et redémarre son exécution dans ce nouveau contexte, puis répond à A en fournissant un code de statut. L’expéditeur est chargé de détruire l’Agent d’origine ainsi que ses ressources.
Retract : Requête de retrait : - destination à source - renvoyez-moi mon Agent.
Un service d’Agents A demande a un service d’Agents B de stopper l’exécution de son Agent et de le lui restituer. B répond en fournissant un code de statut et l’Agent spécifié dans le corps de sa réponse.
Fetch : Requête de rapatriement : - source à destination - renvoyez moi la Classe x.
Pour s’exécuter, un Agent peut avoir besoin de certaines ressources qu’il demande a un service d’Agents distant. La réponse contient un code de statut et le code exécutable exigé.
Message : Requête de message : - toute direction.
Permet aux Agents de communiquer avec leurs environnements.
KQML (Knowledge Query and Manipulation Language) est un langage et un protocole pour faciliter l’échange de messages et de connaissances entre Agents [REX – Chapitre 10]. Ce langage est issu du programme KSE (Knowledge Sharing Effort) de l’ARPA (1992), de même que le langage KIF (voir plus loin).
KQML peut être utilisé comme un langage de programmation chaque fois qu’une application doit communiquer avec un Agent, ou quand deux ou plusieurs Agents doivent communiquer entre eux. KQML intègre un ensemble de performatifs, verbes dérivés des actes du langage, utiles pour un dialogue entre les Agents [CAG – Chapitre 7].
On retrouvera beaucoup d’informations concernant KQML sur le site [KQM].
KIF (Knowledge Interchange Format) est le deuxième résultat du programme KSE de l’ARPA. Le but de KIF est de créer une « lingua franca » pour le développement des applications intelligentes en mettant l’accent sur les interopérations et sur un format commun d’échange parmi les langages de représentation des connaissances. Par nature, KIF fournit une syntaxe pour le contenu des messages échangés entre les Agents. Ce langage ressemble quelque peu à LISP [CAG – Chapitre 7].
Ce langage est plus général que KQML car il est applicable en dehors des Agents. La fonction principale de KIF est de faciliter les échanges d’informations à base de connaissances entre des programmes hétérogènes [REX – Chapitre 10].
On retrouvera beaucoup d’informations concernant KIF, ainsi que ses spécifications, sur le site [KIF].
Dans une société basée de plus en plus sur l’information pour prendre des décisions quelque fois vitales, les agents constituent une réelle menace pour un environnement informatique. En effet les Agents intelligent étant des processus autonomes et pouvant se déplacer sur le réseau, ils peuvent générer des failles de sécurité (destruction d’informations, espionnage, contournement des protections etc.) dont les causes sont les suivantes :
La délégation : On délègue à un Agent une partie de l’autorité de son utilisateur, mais le problème est que l’Agent n’a pas « d’états d’âme ».
La confiance : Une des motivations principales de l’utilisation des Agents et d’éviter à l’utilisateur de faire un travail répétitif, mais un humain fait attention aux effet de bord et aux résultats qu’il obtient, contrairement à un Agent.
La mobilité : Les Agents se déplacent sur les réseaux d’une façon autonome. Comment suivre l’action d’un grand nombre d’agents sur le réseau ?
Les vers : « Les vers sont des programmes autonomes capables de se répliquer en réseau et de se lancer à distance » [IRESTE]. Or cette définition ressemble beaucoup à celle des Agents mobiles. Comment reconnaître un vers d’un Agent ?
Pour contourner ces problèmes, les Agents doivent être créés par des outils sécurisés. C’est à dire, un langage dont toutes les possibilités pouvant créer un problème dangereux (« les verbe dangereux du langage ») sont éliminés. Mais cette solution entraîne forcément une perte de la puissance de l’agent [ENST] .
De plus, l’Agent pose des problèmes éthiques. Imaginez une personne utilisant son Agent pour espionner ou pire, répandre (sous forme de propagande) des idéologies plus que douteuses (les thèses révisionnistes par exemple). Ce dernier type de problème sera difficile à résoudre et pose la même question que la génétique actuellement : Jusque où doit-on aller dans l’application du savoir ?
Julia est un Agent de bavardage créé par Mauldin et Forner de l’université Carnegie-Mellon [M&F]. Le but de Julia est de simuler la conversation humaine. Pour ce faire il intègre un grand nombre d’astuces.
L’agent Julia a été écrit en langage C.
CiFi (Computer Science Citation Finding) est un Agent de recherche de citations, basé sur des règles écrites en Prolog [CIFI]. CiFi recherche une citation sur les serveurs scientifiques présents sur le WEB. Cet agent a été écrit par « The Intelligent Agent Laboratory » basé au département des sciences de l’informatique et de développement du logiciel de l’université de Melbourne (en Australie).
« Il faut savoir que la construction d'un système multiAgent n'est pas simple en soi et que parfois même, elle peut s'avérer très complexe. » [ALA].
La coopération entre les Agents de NetSA : la clé de la réussite
Le système multiAgent NetSA est composé de plusieurs types d'Agents logiciels. Ces Agents sont regroupés dans trois couches.
La première couche comprend les Agents utilisateurs. Ce type d'Agent gère la communication entre le système multiAgent et l'utilisateur. Ainsi, l'utilisateur en passant par le WEB communique ses besoins à l'Agent utilisateur qui lui, ensuite, se charge de les passer aux autres Agents de NetSA.
La deuxième couche comprend trois types d'Agents : l'Agent courtier, l'Agent d'exécution et l'Agent ontologie. L'Agent courtier joue le rôle d'intermédiaire entre l'ensemble des autres Agents. Il offre des services de courtage d'informations et facilite ainsi la communication dans NetSA. L'Agent d'exécution, prend en charge le suivi du déroulement de certaines tâches complexes qui nécessitent souvent une décomposition en sous-tâches. L'Agent d'ontologie se concentre sur la manipulation des différentes ontologies (ou représentations) présentes dans le système.
Finalement, la troisième couche, contient deux types d'Agent ressources : les Agents ressources externes et les Agents ressources internes. Ces deux types d'Agents manipulent des données et sont liées à des sources de données. Le premier type d'Agent ressource est liée à des bases de données internes alors que le deuxième type est liée à des pages WEB externes sur Internet.
[ALA]
Dans cette partie, nous avons vu la mise en œuvre de la technologie Agent à travers des langages (Java, C, C++), des outils (Telescript, AgentBuilder, …) et des protocoles (ATP, KQML et KIF). Nous avons aussi présenté un aperçu des problèmes de sécurité et quelques Agents.
Dans la prochaine partie, nous aborderons le futur de la technologie Agent, avec quelques uns de ses obstacles.
3 -
Perspectives d’avenir
Du fait des problèmes de mise en place des Agents (aux niveaux recherche, technologie et financement), il n’y a aucune application importante basée sur les Agents. Ces difficultés concernent 4 points : intelligence, mobilité et sécurité, conception de méthodologie et d’outils, avoir des Agents génériques. Pour ces raisons, la technologie Agent se trouve dans une phase critique, malgré des perspectives immenses.
Voir dans l’annexe D – Les Agents perceront-ils ?
L’évolution rapide des technologies réseaux et des ordinateurs, ainsi que la croissance des informations disponibles sur Internet, amènent à penser que des centaines de millions de personnes seront connectées, à travers leur ordinateur au travail, à l’école, à la maison mais aussi à travers leur télévision, leur téléphone ou leur voiture, de partout.
Pour permettre cela, les Agents mobiles seront un outil essentiel. Les Agents mobiles sont des programmes qui peuvent se déplacer d’une machine hôte à une autre. L’état d’exécution du programme est sauvegardé, transporté sur la nouvelle machine et restauré, permettant au programme de continuer sa tâche. Les Agents mobiles différent des applets et des processus migrants par le fait qu’ils choisissent eux-mêmes la machine « cible » et le moment de leur départ.
Un autre phénomène, qui encourage l’utilisation des Agents mobiles est la limitation du système client/serveur. En effet, ce modèle a l'avantage de permettre le déplacement du client sur des machines plus petites, éloignées et il fonctionne bien pour certaines applications. Cependant il s’écroule dans d'autres situations, incluant les systèmes fortement distribués, les connexions réseau lentes et de mauvaise qualité.
Cette partie est essentiellement tirée de [KOT] et de [MEI].
La bande passante
La bande passante disponible est énorme et il y en a de plus en plus. Les opérateurs Télécom installent partout des kilomètres de fibres qui sont de plus en plus rapide (NORTEL annonce des fibres à 1,6 TBps en 2000). Par contre, les utilisateurs finaux restent avec des débits faibles, à cause de la boucle locale (modem) ou des communications sans-fil (radio). Et cet écart restera difficile à combler.
Les appareils
mobiles
Le secteur des ordinateurs portables se développe très vite. Les portables, les palmtops, les agendas électroniques, les voitures, les téléphones portables vont pouvoir se connecter à Internet à travers le réseau téléphonique ou même à travers les réseaux sans-fil.
Les utilisateurs
mobiles
Tout le monde aimerait accéder à son courrier électronique depuis n’importe quel ordinateur. Avec la disponibilité de la bande passante, les terminaux WEB vont se développer partout dans les lieux publiques : hôtels, aéroports, … Surtout, si tous les usagers ont accès à leurs applications et leurs fichiers de n’importe quel terminal.
Les intranets
De plus en plus d’organisations disposent des technologies internet pour relier leur collaborateurs à travers des réseaux intranets et extranets. Dans ces réseaux, la coordination et la sécurité sont du ressort des administrateurs réseaux.
Surcharge
d’information
Les données disponibles sur le WEB sont très étendues et grossissent de jour en jour. « Rechercher une aiguille dans une botte de foin » reste une réalité. Les moteurs de recherche, les outils de filtrage, les portails sont des technologies qui permettent de réduire la quantité d’informations transférées.
Customisation
Internet permet de customiser l’accès de chaque utilisateur. Au niveau du serveur et du poste client.
Proxyes
Des sites Proxy, s’interposent entre l’utilisateur du WEB et les sites internets. Comme moyen de réduire la surcharge d’information et comme moyen de customisation, ces sites seront amenés à se développer.
1°> A se connecte à partir de l’ordinateur de sa maison. Il accède à ses données personnelles (sur le site I) et reçoit les informations personnalisées du Proxy I. Il démarre une recherche à travers le net, sur un ensemble de sites. Un Agent se déplacera sur tous les sites choisis, l’un après l’autre, et fera la recherche sur les bases de données hébergées sur le site.
2°> A se connecte à partir de son téléphone portable. Il veut consulter son courrier électronique qui est sur le site I. La communication, de mauvaise qualité, est interrompue plusieurs fois pendant le transfert.
3°> A se connecte à partir de l’ordinateur de sa chambre d’hôtel. Il veut de nouveau consulter sa messagerie et retrouver un fichier dans ses données personnelles (sur le site I). Il en profite pour consulter les informations, personnalisées, envoyées par Proxy I. Ensuite, il récupère le résultat de la recherche effectuée par ses Agents mobiles.
Performance et
dimensionnement
Les systèmes d’Agents mobiles permettent d’épargner la bande passante au détriment de la charge sur la machine hôte. Car les Agents sont écrits dans un langage lent et interprétable, pour des raisons de portabilité et de sécurité et car ils doivent continuer leur exécution dès leur arrivée. Ainsi, sans déconnexion, les Agents mobiles mettent plus de temps à exécuter que des applications classiques.
Heureusement, des progrès significatifs ont été fait dans la compilation juste-à-temps (pour Java) et dans d’autres techniques, qui permettent au code mobile de s’exécuter comme une application native. De même, des groupes de chercheurs explorent de nouveaux moyens pour réduire le coût de la migration.
Ces effets devraient amener à ce que les Agents mobiles ne soient pas plus gourmands que des applications classiques.
Par exemple : Le système Mozart utilise la programmation avec le langage OZ. Les temps de traitement par rapport à une application Java équivalente ont été réduits. [MOZ]
Portabilité et
standardisation
Presque tous les systèmes d’Agents mobiles permettent à un programme de se déplacer librement parmi des machine hétérogènes. Le code est compilé dans une représentation indépendante de la plate-forme puis, à son arrivée, compilé en code natif ou exécuté dans un interpréteur. Pour avoir des Agents largement répandus, le code devra être portable. Il faudra faire un effort important de standardisation pour obtenir cela. Une première approche existe avec le standard MASIF de l’OMG [OMG-MAF], mais ne concerne que les communications inter-systèmes et l’administration. La communauté des Agents mobiles devra poursuivre ce début de standardisation, en choisissant une certaine machine virtuelle, ainsi que des formats de code.
Sécurité
C’est possible de déployer un système d’Agents mobiles qui protège la machine contre les Agents malfaisants. Mais quelques défis restent à relever tels que : protéger les machines sans limiter les droits d’accès des Agents, protéger les Agents des machines malfaisantes et protéger les groupes de machines. Plusieurs groupes travaillent sur ces 3 problèmes, qui devront être résolus pour toutes les applications sur Internet.
Nous parlerons plus loin de la sécurité des Agents.
Les sites Internet doivent avoir une forte motivation pour justifier le coût d’amélioration de leurs systèmes et pour adopter cette technologie. Elle ne sera mise en œuvre que si elle apporte quelque chose à l’utilisateur final : plus d’applications utiles, de meilleurs accès à l’information, permettre les opérations sans connexions.
Continuer dans la voie de l’évolution
· Passer du système client/serveur au système Agents mobiles n’est pas simple. Les chercheurs doivent « baliser » le chemin.
· Le code mobile devrait apparaître d’abord dans les intranets où les environnements sont plus maîtrisés par leurs administrateurs. Ensuite, ils se répandront dans l’Internet, grâce, justement, à ces administrateurs qui auront vu tous le profit à utiliser cette technologie.
Conclusion
La communauté des Agents étant très vaste et avec des points de vue différents, nous avons choisi une vision de ce monde qui nous paraît la plus cohérente. Cette vision n’est pas forcément partagée.
Dans « le guide de survie du Client/Serveur », ORFALI parle à plusieurs reprises du Client/Serveur Intergalactique et des architectures client/serveur à N niveaux. Laissons-lui la parole :
« - Des Agents itinérants. Le nouvel environnement sera peuplé d’Agents électroniques de toutes sortes. Les consommateurs disposeront de leurs propres Agents personnels chargés de veiller sur leurs intérêts ; les entreprises déploieront des Agents pour vendre leurs produits sur le réseau ; des Agents « fouineurs » seront en permanence sur le réseau, collectant des informations pour assurer l’administration des systèmes ou plus simplement, pour établir des statistiques et des tendances. La technologie des Agents comprendra des moteurs de création de scripts multi plate-formes, le workflow et des environnements à code mobile, de type Java, pour permettre aux Agents de vivre sur toute machine du réseau. » [ORF]
De cette recherche, nous pouvons tirer quelques enseignements :
· La technologie Agent est porteuse de beaucoup d’espérances.
· Celle-ci est en pleine ébullition. Beaucoup d’annonces et de conférences ont lieu sur les principaux sujets.
· De nombreux acteurs sont impliqués dans cette technologie. Pourtant, malgré les efforts déployés, il n’y a pas encore eu l’émergence d’un ou de plusieurs chefs de files. Parmi les acteurs, il y a les grands de l’informatique (IBM) et des télécommunications (British Telecom), mais aussi de petites sociétés. On retrouve aussi des acteurs du monde GNU.
· A part les agents de recherche, les agents d’information et les agents pour le commerce électronique, il ne semble pas y avoir de produits matures. A cause des problèmes de sécurité, les agents mobiles sont encore restreints dans leurs déplacements par la disponibilité des serveurs d’accueil et ne sortent pas trop des laboratoires.
· Du fait de la jeunesse du sujet, la documentation est très dispersée parmi plusieurs sites et quelques livres. Un site en amenant un autre, une question reste posée : Est-ce que je n’ai pas oublié quelque chose ?
· A cause de cette jeunesse, beaucoup de mots importants sont mal définis. Il a fallu passer du temps à qualifier certains termes.
Comme travail basé sur cette recherche bibliographique, un projet possible serait de faire une évaluation de plusieurs agents :
· Un agent développé par nous, en Java 2 et avec des classes connues.
· Un agent fabriqué à partir d’un outil du marché (ex : AgentBuilder).
· Un agent du marché, téléchargé à partir d’un site.
Cette activité pourrait être partagée entre plusieurs groupes.
Un autre projet possible serait l’étude et le développement d’une plate-forme universelle d’accueil d’Agents.
4 -
Annexes
Produits
commerciaux
Cette table regroupe les outils de construction d'agents actuellement disponibles. On retrouve un bref résumé ainsi que des liens.
|
Produit |
Lien distant |
Société |
Langage |
Description |
|
AgentBuilder® |
Reticular
Systems, Inc. |
Java |
Agent et Agence intégré Environnement de développement |
|
|
AgenTalk |
<!--<a
href="http://www.cslab.tas.ntt.jp/at/">AgenTalk
Site</a>--> |
NTT/Ishida |
LISP |
Protocole de coordination Multi-Agent |
|
Agent
Building Environment |
IBM |
C++, Java |
Environnement de développement |
|
|
Agent Development Environment (ADE) |
Gensym |
|
Environnement de développement |
|
|
Agentx |
International
Knowledge Systems |
Java |
Environnement de développement |
|
|
Aglets |
IBM Japan |
Java |
Agents mobiles |
|
|
Concordia |
Mitsubishi Electric |
Java |
Agents mobiles |
|
|
DirectIA(r) SDK |
MASA - Adaptive Objects |
C++ |
Kit de développement d’Agents |
|
|
Gossip |
Tryllian |
Java |
Agents mobiles |
|
|
Grasshopper |
IKV++ |
Java |
Agents mobiles |
|
|
iGEN<SMALL>TM</SMALL> |
CHI
Systems |
C/C++ |
Kit de développement d’Agents |
|
|
Intelligent
Agent Factory |
Bits &
Pixels |
Java |
Kit de développement d’Agents |
|
|
Intelligent
Agent Library |
Bits &
Pixels |
Java |
Librairie d’Agents |
|
|
JACK Intelligent Agents |
Agent
Oriented Software Pty. Ltd. |
JACK Agent Langage |
Environnement de développement |
|
|
JAM |
Intelligent
Reasoning Systems |
Java |
Architecture
d’Agents |
|
|
Jumping
Beans |
Ad Astra
Engineering, Inc. |
Java |
Agents mobiles |
|
|
Kafka |
Fujitsu |
Java |
Librairie d’Agents |
|
|
LiveAgent |
AgentSoft Ltd. |
Java |
Construction d’Agents Internet |
|
|
Microsoft Agent |
Microsoft Corporation |
Active X |
Créatures d’Interface |
|
|
Odyssey |
General Magic |
Java |
Agents mobiles |
|
|
UMPRS |
Intelligent
Reasoning Systems |
C++ |
Architecture d’Agents |
|
|
Via: Versatile Intelligent Agents |
Kinetoscope |
Java |
Kit de développement d’Agents |
|
|
Voyager |
Object Space |
Java |
Agent amélioré – ORB |
Projets universitaires
|
Produit |
Organisation de recherche |
Langage |
Description |
|
|
Agent
Building Shell (ABS) |
University
of Toronto |
COOrdination Language (COOL) |
Architecture
d’Agents |
|
|
Agent TCL
(D'Agents) |
Dartmouth
University |
Tcl |
Agents
mobiles |
|
|
Architecture
type-based Development Environment (ADE) |
University
of Potsdam |
Java |
Environnement de développement |
|
|
Bee-gent |
Toshiba
Corporation |
Java |
Environnement de développement |
|
|
Bond
Distributed Object System |
Purdue
University |
Java |
Environnement de développement |
|
|
Cable |
Logica Corporation |
Agent Definition Language, C++ |
Architecture de système |
|
|
Cybele |
Intelligent Automation, Inc. |
unknown |
Infrastructure logicielle |
|
|
DECAF
Agent Framework |
University
of Delaware |
Java |
Environnement de développement |
|
|
dMARS |
Australian Artificial Intelligence Institute Ltd. |
C, C++ |
Environnement d’implantation et de développement d’Agents |
|
|
EXCALIBUR |
Technical
University of Berlin, |
|
Architecture
d’Agents autonomes |
|
|
FarGo |
Distributed
Systems Group, Technion - Israel Institute of Technology |
Java |
Environnement de développement |
|
|
Gypsy |
Technical
University of Vienna |
Java |
Agents mobiles |
|
|
Hive |
The Media
Lab |
Java |
Kit de développement d’Agents |
|
|
Infospiders |
University
of California San Diego - Computer Science Dept. |
unknown |
Agents adaptatifs d’information |
|
|
JAFMAS |
University
of Cincinnati |
Java |
Environnement de développement |
|
|
JATLite |
Stanford University |
Java |
Packages Java pour Multi-Agents |
|
|
JATLiteBean |
University
of Otago |
Java |
Composants JavaBean |
|
|
JIAC |
Technische Universitat Berlin |
Java |
Architecture d’Agents |
|
|
Kasbah |
Massachusetts Institute of Technology |
unknown |
Agents pour le commerce électronique |
|
|
KLAIM |
Universita' Di
Firenze |
Klaim |
Agents
mobiles |
|
|
Knowbot®
System Software |
CNRI |
Python |
Agents mobiles |
|
|
LALO |
CRIM |
LALO |
Environnement de développement |
|
|
Mobiware
Middleware Toolkit |
Columbia
University |
Java |
Environnement de développement |
|
|
MOLE |
University
of Stuttgart |
Java |
Agents mobiles |
|
|
Multi-Agent
Modeling Language (MAML) |
Central
European University |
MAML |
Langage de programmation |
|
|
MultiAgent
Systems Tool (MAST) |
Technical
University of Madrid |
C++ |
Agents hétérogènes |
|
|
Open Agent Architecture<SMALL>TM</SMALL> |
SRI International |
|
Environnement de développement |
|
|
ProcessLink |
Stanford
University |
unknown |
Environnement de développement |
|
|
RETSINA |
Carnegie Mellon University |
|
Agents communiquants |
|
|
Social Interaction Framework (SIF) |
DFKI
(German Research Institute for AI) |
Java |
Environnement de développement |
|
|
Sodabot |
MIT Artificial Intelligence Lab |
unknown |
Environnement de développement |
|
|
Swarm |
Sante Fe Institute |
C |
Environnement de développement |
|
|
TuCSoN |
Universita di Bologna |
|
Environnement de développement |
|
|
Zeus |
British
Telecommunications Labs |
Java |
Kit de développement d’Agents |
Exemple du Chat et de la Souris:
Fichier implémentant le chat (exemple repris de Voyager)
import com.objectspace.voyager.*;
public class Cat extends Agent
{
String home;
public void chase( VMouse mouse ) throws
VoyagerException
{
home = Voyager.getAddress();
// remember where I came from
System.out.println( "cat
waiting 2 seconds until chase..." );
try{ Thread.sleep( 2000 ); }
catch( InterruptedException
exception ) {}
System.out.println( "cat
chases mouse at " +
mouse.getLastObjectAddress());
moveTo( mouse,
"atMouse" );
}
public void atMouse( Mouse mouse )
throws VoyagerException
{
System.out.println( "cat
catches mouse and plays with it" );
mouse.play();
System.out.println( "cat
rests for 8 seconds..." );
try{ Thread.sleep( 8000 ); }
catch( InterruptedException
exception ) {}
System.out.println( "cat
lets mouse go, moves home" );
moveTo( home,
"atHome" );
}
public void atHome() throws
VoyagerException
{
System.out.println( "cat
arrived home" );
dieNow();
}
}
Fichier implémentant la souris (exemple repris de Voyager)
import com.objectspace.voyager.*;
public class Mouse extends Agent
{
public void hide() throws VoyagerException
{
System.out.println(
"mouse running to localhost:8000..." );
moveTo(
"localhost:8000", "at8000" );
}
public void at8000() throws
VoyagerException
{
System.out.println(
"mouse at localhost:8000" );
System.out.println(
"mouse resting 4 seconds before running..." );
try{ Thread.sleep( 4000 ); }
catch( InterruptedException
exception ) {}
System.out.println(
"mouse tries to run to localhost:9000..." );
moveTo(
"localhost:9000", "at9000" );
}
public void play()
{
System.out.println(
"squeak!" );
}
public void at9000() throws
VoyagerException
{
System.out.println(
"mouse escapes to localhost:9000!" );
dieNow();
}
}
Résultats
de l'exécution sur le site 1, port 8000:
>voyager 8000
voyager(tm) 1.0.0, copyright objectspace 1997
address = 157.159.15.4:8000
mouse at localhost:8000
mouse resting 4 seconds before running...
cat catches mouse and plays with it
squeak!
cat rests for 8 seconds...
mouse tries to run to localhost:9000...
cat lets mouse go, moves home
Résultats
de l'exécution sur le site 2, port 9000 :
>voyager 9000
voyager(tm) 1.0.0, copyright objectspace 1997
address = 157.159.15.4:9000
mouse escapes to localhost:9000!
Résultats du lancement du programme
voyager(tm) 1.0.0, copyright objectspace 1997
address = 157.159.15.4:1298
mouse running to localhost:8000...
cat waiting 2 seconds until chase...
cat chases mouse at
157.159.15.4:1298/216-90-198-113-118-139-169-66-130-16-72-1
34-111-72-133-146
cat arrived home
Ron Arkin Georgia
Institute of Technology, USA.
Chitta Baral Arizona State U, USA.
Suzanne Barber U of
Texas at Austin, USA.
Michael Beetz U of
Bonn, Germany.
Domenico Beneventano U of Modena, Italy
Lawrence Cavedon RMIT, Australia.
Paolo Ciancarini U of Bologna, Italy.
Phil Cohen Oregon
Graduate Inst, USA.
Rosaria Conte IP-CNR, Italy.
Giuseppe De Giacomo U of Rome, Italy.
Keith Decker U
of Delaware, USA.
Frank Dignum Eindhoven U, Netherlands.
Alexis Drogoul U of Paris VI, France.
Michael Fisher Manchester Metropolitan Univ, UK.
Stan Franklin U
of Memphis, USA.
Fausto Giunchiglia U of Trento,
Italy.
Piotr Gmytrasiewicz U of Texas at
Arlington, USA.
Barbara Grosz Harvard U, USA.
Robert Guttman MIT
Media Lab, USA.
Henry Hexmoor U of
North Dakota, USA.
Wiebe van der Hoek
Utrecht U, Netherlands.
Mark d'Inverno U of Westminster, UK.
Nick Jennings Queen Mary & Westfield College, UK.
David Kinny U of Melbourne, Australia.
Sarit Kraus Bar-Ilan U, Israel.
Michael Luck U of Warwick, UK.
Henri Lieberman MIT
Media Lab, USA.
John-Jules Meyer Utrecht U,
Netherlands.
Pablo Noriega CSIC,
Spain.
Anand Rao Mitchell Madison Group, UK.
Murray Shanahan Imperial
College, UK.
Carles Sierra CSIC, Spain.
Munindar Singh North
Carolina State U, USA.
Liz Sonenberg U of Melbourne, Australia.
Milind Tambe USC-ISI, USA.
Jan Treur Free
Univ. Amsterdam, Netherlands.
Tom Wagner U
of Massachusetts at Amherst, USA.
Mike Wooldridge Queen Mary
& Westfield College, UK.
Eric Yu U
of Toronto, Canada.
L'intelligence artificielle distribuée (IAD) et les systèmes multi-Agents (SMA) ont joué un rôle important dans le domaine de la résolution de problèmes et la simulation. Cependant nous constatons aujourd'hui qu'un des principaux développements possible de l'IAD et des SMA concerne les applications dans un environnement réel tel qu'Internet, notamment dans le cadre du commerce électronique (en général sous l'appellation d'« Agents intelligents »).
En effet, Internet est actuellement essentiellement utilisé sous la forme de canaux de communication transmettant, à la demande des utilisateurs, du courrier électronique et des pages HTML. Cependant cette utilisation, du fait de son succès, commence à présenter ses limites, de part notamment la quantité sans cesse croissante de données disponibles. Les moteurs de recherche sont une première réponse donnée à ce problème. Ils ne sont toutefois pas entièrement satisfaisants : la recherche doit se faire à l'initiative de l'utilisateur, celle-ci est assez fruste (car basée sur des mots-clés) et enfin le nombre de sites retournés devient de plus en plus gigantesque. L'on souhaiterait donc pouvoir disposer d'un réseau mondial plus « intelligent » et « proactif », c'est-à-dire en symbiose avec les utilisateurs, répondant avec plus de justesse à leurs demandes, voire avançant de telles demandes. Et les technologies qui semblent les plus à même de répondre à cette demande sont celles qui sont liées aux Agents.
Cependant les obstacles liés aux Agents sur Internet sont nombreux, tant au point de vue de la recherche et de la technologie que du financement. De ce fait, il n'existe actuellement aucune application d'importance basée sur les Agents et qui soit opérationnelle pour le grand public sur ce réseau informatique. Or de nombreuses entreprises commerciales n'emboîteront le pas qu'une fois la technologie implantée.
Nous nous trouvons donc dans une phase critique, avec des perspectives immenses (il suffit de voir la capitalisation boursière des entreprises liées au commerce électronique), mais avec encore d'importantes difficultés, tant commerciales que techniques. Ces difficultés concernent quatre points : - l'« intelligence » des Agents, par exemple leur faculté de coopérer; - les contraintes liées à la mobilité et à la sécurité; - la conception et mise en place de méthodologies et d'outils (ateliers de génie logiciel) « orientés Agents »; - enfin la nécessité d'avoir des « Agents génériques » capables de se déplacer au travers de divers protocoles et plates-formes multi-Agents commerciales qui seront présent sur Internet . La première phase de notre travail de recherche concerne cet aspect « Agent générique », au travers du projet GenA / GenAi. Nous comptons par la suite nous impliquer dans l'étude des autres aspects décrits ci-dessus, de façon progressive.
Spécialiste : Laurent Magnin, Ph.D., Paris VI;
[CRI]
Cet exemple a été écrit en Prolog, il permet d’établir si il y a un lien géniteur - enfant entre des individus (les commentaires sont mis entre « /* */ »):
/*Programme en prolog décrivant les liens géniteur - enfant */
/* L’ACCES (« définir de quoi on parle »)*/
domains /*ici on décrit les types d’objet qu’on va utiliser il s’agit des accès */
personne = symbol /*l’objet personne est représenté par une chaîne de caractère : son nom */
predicates /* Ici défini les relations entre les objets */
homme(personne) /* Un homme est une personne */
femme(personne) /* Une femme est une personne */
père(personne, personne) /* Une personne a pour père une personne */
mère(personne, personne) /* Une personne a pour père une autre personne */
parent(personne, personne) /* Une personne a pour parent une autre personne
/* LE CONTENU (les faits)*/
clauses
homme (guillaume). /*guillaume est un homme */
homme (jean). /*jean est un homme */
homme(jacques).
femme(chantal). /* chantal est une femme */
femme(carole). /* carole est une femme */
mère(guilllaume, chantal). /*guillaume à pour mére chantal*/
mère(jean, carole). /*jean à pour mère carole */
père(guillaume, jean). /*guillaume à pour père jean */
père(jean, jacques).
/*LES MECANISME (les régles)*/
parent(X, Y) :- mère(X, Y). /* X a pour parent Y, si X a pour mère Y */
parent(X, Y) :- père (X,Y). /*ou si X a pour père Y */
5 -
Bibliographie
[CAG] – Alper Caglayan et Colin Harrisson - Les Agents - Editions InterEditions 1997
[KLU] - Matthias Klusch – Intelligent Information Agent – Editions Springer
1999.
[L&S] - Langage & Système N°3 de Janvier/Février 2000
[ORF] – Robert Orfali, Dan Harkey et Jeri Edwards – Client/Serveur Guide de Survie 3eme édition – Editions Vuibert 1999
[REV] - Carlo Revelli – Intelligence Stratégique sur Internet – Editions Dunod 1998.
[REX] – Krishna Sankar et al - Bibliothèque de classes Java2 Ressources d’expert – Editions Campus Press 1999
[TAN] – Andrew Tanenbaum – Réseaux - 3eme édition – Editions Dunod 1999
[AGL] - "http://www.Agentlink.org/"
[ALA] – « http://auguste.ift.ulaval.ca/~alaoui/ »
[BTL] – « http://www.labs.bt.com/projects/Agents/research/collaborative.htm »
[CIFI] – « http://www.cs.mu.oz.au/agentlab »
[CLI] – « http://www.fokus.gmd.de/research/cc/ecco/climate/ »
[COP] – « http://www.copernic.com/ »
[CRI] – « http://www.crim.ca/index.epl?selec=2500&href=/rd/Agents.htm »
[ENST] – « http://www.stud.enst.fr/~larcher/agents/etude/ »
[FIP] – « http://www.fipa.org »
[GOS] – « http://www.tryllian.com/ »
[GRA] – « http://www.grasshopper.de/ »
[IBM-JAP] – « http://www.trl.ibm.co.jp/aglets »
[IRESTE]
–
« http://intra/pedagogie/nnormand/Pedago/Reseau/html/Securite.html »
[JAC] – « http://www.Agent-software.com.au/jack.html »
[KIF] – « http://www.csee.umbc.edu/kif »
[KOT] – « http://www.cs.dartmouth.edu/~dfk/papers/kotz:future2/ »
[KQM] – « http://www.csee.umbc.edu/kqml/ »
[LOR] –
« http://www.lorraine-internet.com/jag/DOSSIERS/IA/CE_OFFRE.HTM »
[MEI]
–« http://www.meitca.com/HSL/Projects/Concordia/MobileAgentsWhitePaper.html »
[MIR] –
« www.mitre.org »
[MOZ] – « http://www.mozart-oz.org/] »
[M&F] – « http://forner.www.media.mit.edu/foner/Julia »
[NWA] –
« http://Agents.umbc.edu/introduction/hn-dn-ker99.html »
[OBJ] –
« http://www.objectspace.com/products/prodVoyager.asp »
[OLB] –
« http://perso.club-internet.fr/olberger/python/doc/tut/ »
[OMG-AWG] –
Object Management Group – Agent Working Group «
http://www.objs.com/isig/Agents.html »
[OMG-MAF] –
Object Management Group – Mobile Agent Facility
«http://www.omg.org/techprocess/meetings/schedule/Technology_Adoptions.htm#Mobile_Agents_Facility»
[PYT] – « http://www.python.org/ »
[RET] –
« http://www.Agentbuilder.com/»
[SUN] – « http://www.sun.com/ »
[TOS] –
« http://www2.toshiba.co.jp/beegent/index.htm »
[UMP] –
« http://members.home.net/marcush/IRS/ »
Agents
Definition - Intelligent Software Agents
"http://www.cs.mu.oz.au/isa/"
Concordia - Definition de termes
"http://www.meitca.com/HSL/Projects/Concordia/MobileAgentsWhitePaper.html#_Toc412620121"
Exemples
TACOMA - Operating system support for Agents
"http://www.tacoma.cs.uit.no/"
"http://www.fokus.gmd.de/research/cc/ecco/miami/"
Mobile Agents in Telecommunications
- Webliography (LOCAL VERSION)
"http://comms.eee.strath.ac.uk/~pere/Agents1.html"
COBALT: Agent-based Management
"http://www.irit.fr/~Dominique.Benech/docs/noms98/sld001.htm"
The Ara Platform for Mobile Agents
"http://www.uni-kl.de/AG-Nehmer/Projekte/Ara/index_e.html"
"http://www.ikv.de/index.html"Grasshopper
Organisations
Agentbuilder - Portail sur les Agents
"http://www.Agentbuilder.com/"
"http://bond.cs.purdue.edu/"
AgentLink: A Network of Excellence for
Agent-Based Computing
"http://www.Agentlink.org/"
DECAF - University of Delaware
"http://www.cis.udel.edu/~graham/DECAF/"
D'Agents: Mobile Agents at Dartmouth College
"http://Agent.cs.dartmouth.edu/"
"http://www.botspot.com/"
"http://www.python.org/"
"http://www.fipa.org/spec/FIPA97.html"
"http://www.omg.org/techprocess/meetings/schedule/Technology_Adoptions.htm#Mobile_Agents_Facility
"http://www.Agent.org/"
"http://www.fipa.org/"
OMG Agent Working Group Home Page
"http://www.objs.com/isig/Agents.html"
"http://www.boeing.com/special/Agents99/papers.html"
IJCAI-99 Workshop on Agent Communication
Languages
"http://wwwis.win.tue.nl/acl99/"
Développement
Knowledge Interchange Format Manual
"http://logic.stanford.edu/kif/Hypertext/kif-manual.html"
"http://www.alphaWorks.ibm.com/formula/jkqml/"
"http://www.informatik.uni-stuttgart.de/ipvr/vs/projekte/mole/"
"http://www.lirmm.fr/~gutkneco/madkit/#General"
Portails sur les Agents
Autonomous Agents and Multi-Agent
Systems Table of Contents
"http://www.wkap.nl/sampletoc.htm?1387-2532+1+1+1998"
"http://Agents.umbc.edu/"
"http://www.multiAgent.com/"
Jeff Sutherland's Business Object Component
Technology Web Site
"http://www.jeffsutherland.org/"
Compagnies
"http://www.almaden.ibm.com/cs/wbi/"
Cie de devpt d'Agent - Exemple
"http://Agent-software.com.au/"
Livres - Documentations -
Cours
"http://Agent.cs.dartmouth.edu/papers/index.html#mobile"
"http://Agents.umbc.edu/introduction/hn-dn-ker99.html"
"http://drogo.cselt.it/fipa/general_Agents.htm"
"http://www.doc.mmu.ac.uk/STAFF/B.Berney/research/ag-rev.htm"
Site sur livre Agent Sourcebook
"http://thor.opensesame.com/Agents/Agent_res_academic.html"
Java Intelligent Agent Component Ware (JIAC) - technical documentation
"http://dai.cs.tu-berlin.de/deutsch/intern/dokumentationen/JIAC-doc/main.html"
"http://logic.stanford.edu/kif/Hypertext/kif-manual.html"
"http://www.lirmm.fr/~jq/Cours/Cours_DEA_Agents.html"
"http://thor.opensesame.com/Agents/"
La
Sécurité des Agents Mobiles
"http://www.stud.enst.fr/~larcher/agents/"
Le site de la veille
technologique
"http://www.veille.com/"
"http://perso.club-internet.fr/nygren/ai_frame_3.htm"
"http://www.itin.fr/francais/entreprises/offres-cv-real/travaux/al13/sainz/index.htm"
"http://gla.ecoledoc.lip6.fr/~pereira/multiagent/aglets/"
Mise
en oeuvre et principales caractéristiques de systèmes d'agents mobiles
"http://www-inf.int-evry.fr/~bernard/ipr/projets97-98/agents-rapport/ "
"http://www.olf.gouv.qc.ca/ressources/internet/fiches/8874827.htm"
Ecole d'été sur la Construction
d'Applications Réparties
"http://sirac.imag.fr/ecole/98/cours/"
6 -
Glossaire
Agent : un Agent est un logiciel autonome, réactif et capable de communiquer avec les autres Agents.
Agent courtier : c'est un Agent qui permet de faire de courtage d'information au sein d'un système multiAgent. Une des fonctions de cet Agent est qu'il permet de trouver les Agents selon leurs services ou capacités.
Agent exécution : c'est un Agent qui supervise l'exécution de certaines tâches complexes. Cet Agent décompose ces tâches en sous-tâches.
Agent ressource : c'est un Agent qui contrôle une ou plusieurs sources de données. Ces sources peuvent être internes ou externes.
Agent ontologie : c'est un Agent qui s'occupe des différentes ontologies du système.
Agent utilisateur : c'est un Agent qui prend en charge les tâches de l'usager.
Ontologie : Une ontologie peut être considérée comme l'univers de discours d'un domaine donné (définition de l’intelligence artificielle).
KQML : Knowledge Query and Manipulation Language, c'est un langage de communication entre Agents.
Système multiAgent : un système multiAgent est un système qui comprend un ensemble d'Agents. Si les Agents sont en coordination alors on parle d'un système multiAgent collaboratif. Si les Agents sont en compétition, on parle alors d'un système multiAgent compétitif.