E2 - Java Forum Stuttgart

Agenten-Technologien
in Java
Jochen Hiller
[email protected]
Java Forum Stuttgart, 28.06.2001
JFS2001 / Slide 1
Bauer & Partner - The Business and Technology Group. © 2001
Was sind Software-Agenten ?
 Agenten sind Software-Objekte, die sich eigene Modelle von Ihrer
Umgebung bilden und aufgrund dieser Entscheidungen treffen, und
Handlungen ausführen.
 Diese können zur Beschaffung und/oder Verarbeitung von Informationen
eingesetzt werden.
 Software-Agenten sind:
 Autonom
 Kommunikativ
 Kooperativ
 Können Wissen verarbeiten
 Lernfähig
 Mobil
JFS2001 / Slide 2
Bauer & Partner - The Business and Technology Group. © 2001
Informationen
Handlungen
JFS2001 / Slide 3
Modelle
Modell eines Agenten
Plausibilität
Entscheidungen
Bauer & Partner - The Business and Technology Group. © 2001
Architektur eines Agenten
SENSOR
AKTOR
Environment
JFS2001 / Slide 4
• Ziele
• Wünsche
• Intentionen
• Erfahrungen
Inferenzmaschine
Modell
Bauer & Partner - The Business and Technology Group. © 2001
Informationen
Entscheidung
Modell- Filtern Beschaffen
bildung
Agenten zur Entscheidungs-Unterstützung
Fortschritt
JFS2001 / Slide 5
Bauer & Partner - The Business and Technology Group. © 2001
Was haben Software-Agenten mit OO / KI zu tun?
 Agententechnologien verbinden die Ideen der Künstlichen Intelligenz
(KI) mit den Prinzipien der Objekt-Orientierung
 Übertragen der realen Welt in ein Software-Paradigma: Einzelne agierende „Personen“
werden durch Agenten repräsentiert, die eigene Ziele verfolgen, ein Modell zugrunde
liegen haben (z.B. Reise-Agent, Logistik-Agent, Trader)
 Kapselung: Ein Agent kapselt seine eigenen Ziele und Regeln. Damit wird ein Agent zu
einer in sich abgeschlossenen, übersichtlichen Einheit
 Verteilung: Ein Agentensystem entsteht erst durch eine Reihe von kommunizierenden
Agenten. Die Komplexität eines Gesamtsystems liegt dann in der Gesamtarchitektur
und in dem entsprechenden „Agenten-Modell“.
 Agenten sind in dem Sinne komplexere Objekte, mit eigenständigem,
aktivem Verhalten und der Fähigkeit zum Lernen
 Agenten werden heute mit OO Technologien implementiert.
 Monolithische KI Systeme (wie Expertensysteme) werden mit
Agententechnologien aufgebrochen, modularisiert.
JFS2001 / Slide 6
Bauer & Partner - The Business and Technology Group. © 2001
Warum werden Agenten-Technologien mit Java
umgesetzt ?
 Plattformunabhängigkeit: Ein Java-Agent kann auf einer beliebigen Java
Plattform ablaufen
 Netzwerk-zentriert: Java kann sowohl Daten wie auch Code sehr
einfach im Netzwerk nutzen wie auch migrieren (Mobilität)
 Security-Konzept: Java arbeitet in einer Sandbox. D.h. Agenten, die auf
eine Plattform wechseln, haben eine definierte Laufzeitumgebung, ohne
die Sandbox (ohne Rechte) verlassen zu können
 Dynamisches Binden: Klassen werden erst zur Laufzeit gebunden.
Damit hat man die notwendige Flexibilität, sehr dynamische Plattformen
bereitzustellen
 Reflection, Proxies: Erleichtern die Implementierung von AgentenPlattformen.
JFS2001 / Slide 7
Bauer & Partner - The Business and Technology Group. © 2001
Welche Java / XML Standards gibt es im Umfeld
Agententechnologien (Auszug) ?
 Object Management Group: Mobile Object Facility (MAF)
 Ergänzung der OMG Standards um die Mobilität von Agenten
 Siehe http://www.omg.org/technology/documents/formal/mobile_agent_facility.htm
 Foundation for Intelligent Physical Agents (FIPA)
 Organisation vergleichbar der OMG für Agenten-Technologien: http://www.fipa.org
 Implementierung sind weitestgehend Java basierend. Es gibt Referenz-Installationen
und Interoperabilitäts-Tests
 SUN JSR 87: Java Agent Service (JAS)
 Siehe http://www.jcp.org/jsr/detail/87.jsp. Reservierter Namespace: javax.agent
 Community Draft: Juli 2001
 SUN JSR 94: Java Rules Engine API
 Siehe http://www.jcp.org/jsr/detail/94.jsp. Reservierter Namespace: javax.rules.
 Public Draft angekündigt für April 2001, noch nicht verfügbar
 RuleML: XML Sprache zur Repräsentation von Fakten/Regeln
 Siehe http://www.dfki.uni-kl.de/ruleml/. Erster RuleML Editor auf Basis von Mandarax
JFS2001 / Slide 8
Bauer & Partner - The Business and Technology Group. © 2001
FIPA – Referenz-Architektur
 Agent
 Directory Facilitator (DF)
 Agent Management System
(AMS)
 Message Transport Service
(MTS)
 Z.B. über IIOP, RMI, HTTP
 Agent Platform (AP)
 Software
JFS2001 / Slide 9
Bauer & Partner - The Business and Technology Group. © 2001
Frei verfügbare Agenten-Plattformen (Auszug)
 FIPA-OS (emorphia): http://fipa-os.sourceforge.net/
 Comet Way JAK: http://www.cometway.com/jak
 Aglets (IBM): http://www.trl.ibm.com/aglets/
 IBM Agenten-Plattform
 Seit kurzem auch OpenSource: http://aglets.sourceforge.net/
 JADE (Telecom Italia Lab) http://sharon.cselt.it/projects/jade/
 Java Agent DEvelopment Framework, FIPA compliant
 Jackel (UMBC): http://jackal.cs.umbc.edu/
 D‘Agents (Dartmouth College): http://agent.cs.dartmouth.edu/
 Früher: Agent Tcl, eine der ersten Agenten-Plattformen
 MOLE (Uni Stuttgart): http://mole.informatik.uni-stuttgart.de/
JFS2001 / Slide 10
Bauer & Partner - The Business and Technology Group. © 2001
Kommerzielle Agenten-Plattformen (Auszug)
 Living Systems: http://www.living-systems.com
 Anbieter von Martkplatz-Lösung auf Basis von Agententechnologien
 Produkte: living agents, living markets
 IKV++: GrassHopper Agent platform http://www.grasshopper.de
 Produkt: GrassHopper, WebHopper
 OMG MASIF und FIPA-97 Add-on Komponenten
 ObjectSpace: Voyager http://www.objectspace.com/
 Product: Voyager ORB Professional, Object Mobility and Mobile Agents
 J2EE kompatibler Application Server on top
 Reticular: AgentBuilder: http://www.agentbuilder.com/
 Toolset zur Konstruktion Intelligenter Software Agenten-Systeme
JFS2001 / Slide 11
Bauer & Partner - The Business and Technology Group. © 2001
Warum benötigt man Rule Engines ?
home brewed
code
transaction
persistency
security ..
EJB
server
..
business
logic
EJB
server
..
rule
engine
JFS2001 / Slide 12
costs, risks
Bauer & Partner - The Business and Technology Group. © 2001
Mandarax– Warum eine weitere Rule Engine ?
 Die meisten Ansätze basieren auf Programmiersprachen wie Prolog und
CLIPS
 Es gibt sehr wenige OpenSource Implementierungen, und nur eine
einzige Java basierende (JESS)
 Java basierende Rule Engines müssen in heutige Architekturen
integrierbar sein (z.B. EJB)
 Siehe Architektur Vorschlag von SUN Engineers in JavaReport 07/2000
 JSR 94: Java Rules Engine API
 Grundsätzliche Idee: Transparente Integration von bestehenden
Anwendungen über einfache Adapter / Connectoren Technologie
 Direkte Nutzung des Objekt-Modelles als Wissensbasis für Fakten
 Tools fehlen zum Bearbeiten von Wissensbasen und Fakten / Regeln
 Graphische Tools
 Nutzung von offenen XML basierenden Standards zur Repräsentation
JFS2001 / Slide 13
Bauer & Partner - The Business and Technology Group. © 2001
Kernelemente der logischen Programmierung (am
Beispiel Prolog)
 Fact
 Jens ist der Vater von Max.
Klaus ist der Vater von Jens.
 father (Jens, Max).
father (Klaus, Jens).
 Rule
 Wenn X Vater von Z UND Z Vater von Y ist, dann ist X Grossvater von Z.
 grandfather (X, Y) <- father (X,Z), father (Z,Y).
 Query
 Ist Klaus Grossvater von Max ?
 grandfather (Klaus, Max)?
 Inference Engine
 Die Abstrakte Maschine, die die Fakten und Regeln auflöst, und Queries beantworten
kann.
JFS2001 / Slide 14
Bauer & Partner - The Business and Technology Group. © 2001
Klassische Implementierung von Geschäftslogik
 If the value of all transactions of a customer is more than 100$ in
one year then he qualifies for a discount of 10%.
// Klassische Implementierung,
// Geschäftsregeln sind hart codiert
public Discount getDiscount (Customer customer) {
int turnover = customer.getTurnover (12);
//
//
//
if
Regeln sind hier implementiert,
der Constructor fuer Discount
erzeugt einen prozentualen Discount von 10%
(turnover > 100) return new Discount (10, true);
if ..
}
JFS2001 / Slide 15
Bauer & Partner - The Business and Technology Group. © 2001
Mandarax – Definition von Fakten / Regeln
 If the value of all transactions of a customer is more than 100 $ in
one year then he qualifies for a discount of 10%.
// Instanzen werde mit einer Factory erzeugt, zusaetzlich wird eine weitere
// Utility-Klasse benutzt, die das generieren von Objekten weiter vereinfact
LogicFactory factory = LogicFactory.getDefaultFactory ();
LogicFactorySupport factorySupport = new LogicFactorySupport (factory);
// Erzeuge Term fuer "a customer"
Term aCustomer = factory.createVariableTerm ("aCustomer", Customer.class);
// Erzeuge Term fuer "one year" (= 12 Monate)
Term oneYear = factory.createConstantTerm (new Integer (12));
// Erzeuge Term fuer "the value of all transactions of a customer in one year".
// new Integer(12) wird automatisch in einen constanten Term umbewandelt
Class[] parameterTypes = {Integer.TYPE};
Method aMethod = Customer.class.getMethod ("getTurnover", parameterTypes);
Function turnover = new JFunction (aMethod);
Term valueOfCustomer = factorySupport.cplx.(turnover, aCustomer, new Integer (12));
// Erzeuge Premisse. Das Standardpredikate > ist vordefiniert
Fact premisse = factorySupport.fact (IntArithmetic.GREATER_THAN, valueOfCustomer,
new Integer (100));
// ...
JFS2001 / Slide 16
Bauer & Partner - The Business and Technology Group. © 2001
Mandarax – Arbeiten mit Regeln / Inference Engine
 Regeln werden in der Wissensbasis hinterlegt.
 Mittels der Inference Engine kann eine Query auf die
Wissensbasis abgesetzt werden
// Implementierung mit Geschaeftsregelframework
public Discount getDiscount (Customer customer) {
// Erzeuge Anfrage
Class[] parameters = {Customer.class, Discount.class};
Predicate getsDiscount = new SimplePredicate("get discount",parameters);
Fact query = factorySupport.fact (getsDiscount, customer, "a discount");
// Anfrage stellen
InferenceEngine ie = new ResolutionInferenceEngine ();
KnowledgeBase kb = ..; // hier sind die Regeln gespeichert
Result result = ie.query (query, kb);
Replacement replaced = result.getReplacements ()[0];
Discount discount4Customer = (Discount) replaced.replacement.getObject ();
return discount4Customer;
}
JFS2001 / Slide 17
Bauer & Partner - The Business and Technology Group. © 2001
Mandarax – Integration von Fakten
 AutoFacts erleichtern die Integration von bestehenden
Datenbeständen, z.B. Datenbanken, Objects in Memory, EJB‘s
 Die Implementierung basiert auf einem Iteratoren Konzept, wo
Fakten zur Laufzeit ausgewertet werden, und dann zur
Verfuegung stehen.
// DB ist hier eine Klasse die eine Datenbank simuliert
AutoFacts af = new AutoFacts () {
public Collection getExtension (Class clazz) {
if (clazz==Customer.class) return DB.getCustomers ().values ();
if (clazz==Category.class) return DB.getCategories ().values ();
if (clazz==KindOfPayment.class) return DB.getKindsOfPayment ().values ();
return super.getExtension (clazz);
}
};
// benutze vordefiniertes Standardpraedikat aus dem org.mandarax.math package
Predicate[] predicates = {DoubleArithmetic.GREATER_THAN};
af.setPredicates (predicates);
JFS2001 / Slide 18
Bauer & Partner - The Business and Technology Group. © 2001
Mandarax – Wissensbasis in RuleML (v0.8)
 Mandarax ist der erste verfügbare Editor für RuleML basierende
Wissensbasen
<?xml version="1.0" encoding="UTF-8"?>
<rulebase>
<imp>
<_head>
<atom>
<_opr>
<rel>grandfather</rel>
</_opr>
<var>x</var>
<var>z</var>
</atom>
</_head>
<_body>
<and>
<atom>
<_opr>
<rel>father</rel>
</_opr>
<var>y</var>
<var>z</var>
</atom>
JFS2001 / Slide 19
<atom>
<_opr>
<rel>father</rel>
</_opr>
<var>x</var>
<var>y</var>
</atom>
</and>
</_body>
</imp>
<fact>
<_head>
<atom>
<_opr>
<rel>father</rel>
</_opr>
<ind>Jens</ind>
<ind>Max</ind>
</atom>
</_head>
</fact>
</rulebase>
Bauer & Partner - The Business and Technology Group. © 2001
Welche Java Implementierungen von regelbasierten
Systemen sind verfügbar ?
 Frei verfügbare Implementierungen:
 JESS: Java Expert System Shell
– Von sandia.gov, Ernest J. Friedman-Hill
– Siehe http://herzberg.ca.sandia.gov/jess
– (fast) CLIPS kompatible Expert Shell
 Mandarax:
– Siehe http://www.mandarax.org
 Kommerzielle Produkte:
 ILOG: JRules 3.0
– Siehe http://www.ilog.com/products/rules/engines/jrules31/
– Kommerzielles Produkt auf Basis der vorigen C++ Produkte
– Integriert sich z.B. in die Portal-Technologien von BEA WebLogic
 BlazeSoft (Brokat): Advisor Rule Server and Engine
– Siehe http://www.blazesoft.com/products/advisor_server.html
– Pure Java Lösung
JFS2001 / Slide 20
Bauer & Partner - The Business and Technology Group. © 2001
Oryx – Das Toolkit zu Mandarax
 Wurde von Jens Dietrich ([email protected]) als
Add-On Tool zu Mandarax entwickelt
 Siehe http://www.jbdietrich.de
 Frei für den Unversitären Bereich
 Kommerzielle Lizenzen bei Jens Dietrich erhältlich
JFS2001 / Slide 21
Bauer & Partner - The Business and Technology Group. © 2001
Oryx - Features
 Oryx bietet Unterstützung für die persistente Ablage
 Java Serialisierung
 XML basierte Ablage (intern, RuleML v0.8 kompatibel)
 Swing UI components
 Wissensbasis-Editor, Fakt und and Regel-Editor,
 Ableitungsbäume, Ad-Hoc Queries
 Blueprint support für Lesbare Regeln
 Web UI components
 Umfangreicher support um JSP‘s zu entwerfen, basierend auf Tag-Libraries
 Basiert auf dem MVC-Konzept, geringer Code im Controller
 Vorgefertigte JSP‘s für den Wissensbasis, Fakt und Regel Editor
 >30 unterschiedliche tags
 Erweiterte Inference Engine
 Ermittlung von N Ergebnisse.
 Die Anzahl der zu ermittelnden Ergebnisse kann bei der Query mitgegeben werden.
JFS2001 / Slide 22
Bauer & Partner - The Business and Technology Group. © 2001
Sonstige Links / Resources
 FIPA: Foundation for Intelligent Physical Agents,
http://www.fipa.org/
 UMBS AgentWeb: http://agents.umbc.edu/
 EU ESPRIT: http://www.agentlink.org/
 Cetus-Links: http://www.cetus-links.org/oo_mobile_agents.html
 Agenten in Raucherkinos. Grundlagen und Hintergründe
 Artikelreihe in Java Magazin, ab JavaMagazin 07/2001
 Christian Dannegger, Dr. Klaus Dorer (living systems AG)
JFS2001 / Slide 23
Bauer & Partner - The Business and Technology Group. © 2001