class Deliberator

Die Entscheidungskomponente des Agenten

Public Methods

void addOption(int optionId )
Hinzufuegen einer Handlungsoption
void addPotentialConstraint(int constraintId )
Hinzufuegen einer potentiellen Nebenbedingung
Deliberator( Effectors *anEffector )
Konstruktor uebernimmt den Effektor
Deliberator( const Array<int>& optionIds, const Array<int>& potentialConstraintIds, Effectors *anEffector )
Konstruktor uebernimmt Handlungsoptionen, potentielle Nebenbedingungen und den Effektor
void startDeliberation()
Führt den Entscheidungsprozeß durch
~Deliberator()
Destruktor

Private Fields

Option* currentIntention
Die momentane Absicht
Array <Option *> options
Die Handlungsoptionen
Array <Constraint *> potentialConstraints
Die potentiellen Nebenbedingungen
Option* previousIntention
Die vorherige Intention
Effectors* theEffector
Der Effektor

Private Methods

int indexOfBestDesire( const Array<Option *>& desires )
Waehlt den Wunsch mit dem groessten Nutzen aus
void initialize( const Array<int>& optionIds, const Array<int>& potentialConstraintIds )
Initialisiert die internen moeglichen Wuensche und Nebenbedingungen
int minConstraintUtility()
Liefert den minimalen Nutzen, den das Einhalten einer Nebenbedingung bringen muss, damit die Bedingung in die Liste der einzuhaltenden Bedingungen aufgenommen wird
int minDesireUtility()
Liefert den minimalen Nutzen, den die Umsetzung einer Handlungsoption bringen muss, damit sie in die Liste der Wuensche aufgenommen wird

Documentation

Die Entscheidungskomponente des Agenten.

Der Deliberator waehlt aus einer Reihe von Handlungsoptionen (Objekte der Klasse Option und ihrer Subklassen) wünschenswerte aus, und setzt dann den nuetzlichsten, unter den momentan sinnvollen Nebenbedingungen realisierbaren Wunsch um. Die Liste der beruecksichtigten Optionen und Nebenbedingungen ist zur Laufzeit aenderbar.

Die zentrale Methode ist startDeliberation. Sie steuert den Ablauf des Entscheidungsprozesses. Dieser Entscheidungsprozeß wird jedesmal gestartet, wenn neue Sichtinformationen eintreffen, oder die Action-Queue von Effectors leer ist. Das heißt, daß jede Handlungsoption jederzeit, also auch während ihrer Umsetzung, in der Lage sein muß, den erwarteten Nutzen ihrer Umsetzung bis zum Ende zu berechnen.

Von der Klasse wird nur ein Objekt erzeugt. Die Klasse ist nicht zur Vererbung geeignet.

Quelltext

[Header | [Implementierung]

CVS Informationen zum Interface

  **************************************************
  *
  * Aktueller Stand
  *
  *   $RCSfile: Deliberator.h,v $
  *   $Revision: 1.18 $
  *   $Date: 1998/08/14 13:20:14 $
  *   $Author: myritz $ 
  *
  **************************************************
  
Deliberator( Effectors *anEffector )
Konstruktor uebernimmt den Effektor. Es werden alle moeglichen Wuensche und alle moeglichen (sinnvollen) Nebenbedingungen verwendet.

Deliberator( const Array<int>& optionIds, const Array<int>& potentialConstraintIds, Effectors *anEffector )
Konstruktor uebernimmt Handlungsoptionen, potentielle Nebenbedingungen und den Effektor
Parameters:
optionIds -
potentialConstraintIds -
anEffector - Zeiger auf den Effektor

void addOption(int optionId )
Hinzufuegen einer Handlungsoption. Ist die Option bereits in der Liste der Optionen enthalten, geschieht nichts.
Parameters:
optionId - Die Id der hinzuzufuegenden Option.

void addPotentialConstraint(int constraintId )
Hinzufuegen einer potentiellen Nebenbedingung. Ist sie bereits in der Liste der potentiellen Nebenbedingungen enthalten, geschieht nichts.
Parameters:
constraintId - Die Id der hinzuzufuegenden Nebenbedingung.

void startDeliberation()
Führt den Entscheidungsprozeß durch. Hier wird eine recht flexible, sog. BDI-Architektur eingesetzt (B - Belief, D - Desire, I - Intention). Im Einzelnen passiert bei der Entscheidungsfindung folgendes:

Als erstes werden die geforderten Nebenbedingungen bestimmt. Dazu wird jedes Element von potentialConstraints nach seiner expectedUtility gefragt. Ist sie groesser als minConstraintUtility(), wird sie in die Liste der geforderten Nebenbedingungen aufgenommen.

Als nächstes werden die Wünsche bestimmt. Dazu wird von jedem Wunsch in options eine Kopie angelegt, der die geforderten Nebenbedingungen mitgeteilt werden (per Aufruf von setConstraints() ). Liegt der erwartete Nutzen über minDesireUtility(), wird die Handlungsoption in die Liste der Wünsche aufgenommen. Interessant ist hier vor allem die Bestimmung der Nützlichkeit eines Wunsches durch Option::computeExpectedUtility().

Nun wird aus den Wünschen eine Absicht bestimmt. Dabei spielen die letzte Absicht, zu deren Umsetzung sich der Agent entschlossen hat (committed intention), die Umsetzbarkeit eines Wunsches, und nicht zuletzt der Nutzen des jeweiligen Wunsches eine Rolle. Dieser Schritt ist in die Methode indexOfBestDesire ausgelagert. Konnte kein umsetzbarer Wunsch ermittelt werden, wird der Standardwunsch Option zur Absicht bestimmt.

Bevor ein konkreter Plan entwickelt wird, hat die Absicht die Gelegenheit, Daten mit der bisherigen Absicht abzugleichen (mit dem Aufruf von adaptToPreviousIntention() ).

Als letztes wird die nun festgelegt Absicht aufgefordert, einen Plan zu ihrer Umsetzung zu erzeugen (mit generatePlan). Dieser Plan wird nun den Effectors zur Ausführung übergeben.

~Deliberator()
Destruktor

class NoDesiresLeftException: public Exception
Private Fehlerklasse, die in indexOfBestDesire ausgeloest wird

Effectors* theEffector
Der Effektor

Array <Option *> options
Die Handlungsoptionen

Array <Constraint *> potentialConstraints
Die potentiellen Nebenbedingungen

Option* currentIntention
Die momentane Absicht

Option* previousIntention
Die vorherige Intention

void initialize( const Array<int>& optionIds, const Array<int>& potentialConstraintIds )
Initialisiert die internen moeglichen Wuensche und Nebenbedingungen

int indexOfBestDesire( const Array<Option *>& desires )
Waehlt den Wunsch mit dem groessten Nutzen aus. Dabei werden die Abbruchkosten der Umsetzung der bisherigen Absicht beruecksichtigt ( cancellationCost() ). Ist das Array mit den Wuenschen leer, wird eine Exception erzeugt, da dann kein sinnvoller Index zurueckgegeben werden kann.
Throws:
Deliberator ::NoDesiresLeftException, wenn das übergeben Array desires ler ist.
Returns:
Wert zwischen 0 und desires.count()-1
Parameters:
desires - Array mit den Wuenschen, aus denen der beste ausgewaehlt wird.

int minConstraintUtility()
Liefert den minimalen Nutzen, den das Einhalten einer Nebenbedingung bringen muss, damit die Bedingung in die Liste der einzuhaltenden Bedingungen aufgenommen wird
Returns:
Ein Wert zwischen NEUTRAL_UTILITY und MAX_UTILITY.

int minDesireUtility()
Liefert den minimalen Nutzen, den die Umsetzung einer Handlungsoption bringen muss, damit sie in die Liste der Wuensche aufgenommen wird
Returns:
Ein Wert zwischen NEUTRAL_UTILITY und MAX_UTILITY.


This class has no child classes.

alphabetic index hierarchy of classes


Hauptseite

Einleitung | Architektur | Dynamische Zusammenhänge | Referenzhandbuch | FAQ | Anhang A | Anhang B

generated by doc++