"Intelligent Virtual Characters" Künstliche Intelligenz in Spielen - Quan Nguyen () Dozent: Dr. Michael Kipp
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
“Intelligent Virtual Characters”
Künstliche Intelligenz
in Spielen
Quan Nguyen
(quan.nguyen@dfki.de)
Dozent: Dr. Michael Kipp
18.08.2006Abstract Die vorliegende Arbeit beschäftigt sich mit einigen Techniken zur Modellierung und Implementierung von künstlicher Intelligenz in Spielen. Zunächst werden Techniken zur Modellierung von Non-Personal-Characters (NPCs) vorgestellt, mit denen es den NPCs möglich ist, sich intelligent und selbständig zu bewegen (Steering, A*-Algorithmus). Auch wird anhand von verschiedenen Lernmethoden (Lernen durch Feedback) gezeigt, wie man NPCs unterschiedlich ausbilden und individualisieren kann. Am Beispiel des Spiels “Black & White” kann man sehen, wie man Perzeptrone benutzen werden, um Bedürfnisse von Agenten zu repräsentieren und zu trainieren. Um Entscheidungen und Vorhersagen treffen zu können, werden endliche Automaten, Entscheidungsbäume und N-Gramme erläutert. Zum Schluss wird eine Möglichkeit gezeigt, wie die Kommunikation zwischen KI-Entwickler und Programmierer bei der Entwicklung von KI erleichtert werden kann.
Inhaltsverzeichnis:
1 EINLEITUNG ........................................................................................................................................... 4
2 TECHNIKEN ZU MODELLIERUNG VON NON-PERSONAL-CHARACTERS (NPCS) ................... 6
2.1 BEWEGEN VON NPCS ........................................................................................................................ 6
2.1.1 Intelligente Bewegung der Agenten durch das Gelände ....................................................... 6
2.2 ENTSCHEIDUNGEN VON NPCS ........................................................................................................... 9
2.3 PROGRAMMIERUNG VON AGENTEN ................................................................................................... 10
2.4 VORHERSAGEN VON NPCS .............................................................................................................. 12
2.4.1 N-Gramm-Modell .................................................................................................................... 12
2.5 LERNEN VON NPCS.......................................................................................................................... 16
2.5.1 Verschiedene Lernmethoden ................................................................................................ 18
3 KONKLUSION....................................................................................................................................... 20
3.1 KI-FORSCHUNG VS. KI IN SPIELEN ................................................................................................... 20
3.2 ZUKÜNFTIGE ENTWICKLUNG .......................................................................................................... 21
3.3 ZUSAMMENFASSUNG ........................................................................................................................ 21
4 LITERATUR........................................................................................................................................... 231 Einleitung Aktuelle Computerspiele arbeiten mit zunehmend imposanter werdenden Grafiken und immer komplexeren Storys. Innerhalb dieser modernen Spiele spielt die künstliche Intelligenz (KI) der computergesteuerten Agenten eine zentrale Rolle. Im Vergleich zur Grafik eines Spieles besitzt die KI hinsichtlich der Vermarktung lediglich einen untergeordneten Stellenwert, da sie nicht in dem Maße präsentiert werden kann wie eine neue Grafik-Engine. Eine gute KI mit ihren besonderen Facetten wird im Hintergrund, im Detail und erst langfristig (im Spielspaß) erkennbar – nicht in medienwirksamen, fotorealistischen Explosionen und realitätsnahen Physikeigenschaften [1]. Die künstliche Intelligenz eines neuen Spieles muss mindestens den heutigen Standards genügen – oder diese noch übertreffen. Dadurch dass KI nicht auf Fotos gebannt und präsentiert werden kann, wird sie daher häufig nur verbal hochgepreisen und als „revolutionär neu“ und überaus komplex beschrieben, um überhaupt in der Fachpresse Beachtung zu finden. Denn ungeachtet der schwierigen Vermarktung spielt die KI eine entscheidende Rolle für den Erfolg eines Spiels. Man erwartet ganz selbstverständlich, eine gute und nicht leicht zu durchschauende KI. Ein Spiel ohne diese Voraussetzung ist bereits zum Misserfolg verdammt – selbst bei einer hervorragenden Grafik. Der Spieler will Herausforderungen und lang anhaltenden Spielspaß, welcher neben einer ausgeklügelten Story nur durch eine gute KI ermöglicht werden kann. Ein Spiel mit schlechten Kritiken in der Fachpresse aufgrund der KI wird zum „Ladenhüter“. Dies ist auch der Grund dafür, dass viele Spieleentwickler immer mehr Geld in „Forschung“ und Entwicklung von künstlicher Intelligenz stecken, da die Computerspiele Industrie ein großer Markt ist und die Entwicklung und der Verkauf eines einzigen Spiels schon das Schicksal eines Unternehmens besiegeln kann. Spieler erwarten keine perfekte KI, da man weiß, dass man noch weit davon entfernt ist. Sie erwarten nur eine KI, die ihnen den Spielspaß solange wie möglich erhalten, in dem sie „mitdenken“ (passen ihre Route den Umständen an), sich nicht so schnell durchschauen lassen (haben kein fest gefahrenes Muster) und den Spieler immer wieder überraschen (interagieren mit der Umwelt). Um diese Wünsche zu erfüllen, haben Spielehersteller mittlerweile eigene KI Abteilungen, die immer ausgeklügeltere Techniken entwickeln und verfeinern.
Im Folgenden werden diese Techniken eingehend betrachtet und erläutert. Hierbei wird erläutert, wie eine solche KI aussieht, wie man sie implementiert und welche Ideen dahinter stehen, so dass ein kleiner Einblick in das Gehirn von Computerspielen gewonnen wird. Zuerst werden einige Techniken zur Modellierung von Non-Personal-Characters (NPCs) vorgestellt, um den NPCs zu ermöglichen, sich intelligent und selbständig zu bewegen (Steering und A*-Algorithmus). Um Entscheidungen von NPCs zu realisieren, werden Endliche Automaten und Entscheidungsbäume besprochen. Zur Vorhersage von menschlichen Zügen werden N-Gramme, sowie ihre Benutzung, Training und weitere Einsatzmöglichkeiten erläutert. Anschließend wird die Lernphase von Agenten anhand von verschiedenen Lernmethoden geklärt. Damit wird gezeigt wie man NPCs unterschiedlich ausbilden und individualisieren kann. Am Beispiel des Spiels “Black & White” wird man sehen, wie man Perzeptrone benutzen kann, um Bedürfnisse von Agenten zu repräsentieren. An einer Methode wird erläutert, wie es möglich ist, eine Brücke zwischen KI-Designer und Programmierer zu schlagen, da Vertreter dieser beiden Gruppen die Problematik bei der Realisierung der KI aus zwei verschiedenen Perspektiven betrachten, kennen sie die Grenzen der jeweils anderen Disziplin nicht. Abschließend wird auf das Zusammenspiel von KI-Forschung und KI in Spielen, sowie die zukünftige Entwicklung der künstlichen Intelligenz in Spielen eingegangen.
2 Techniken zu Modellierung von Non-Personal-
Characters (NPCs)
Eine häufig aufkommende Frage (hinsichtlich der KI in Computerspielen) zielt auf die
Bewegung der Non-Personal-Characters (NPCs) ab. Welche Techniken zeigen den Agenten
den Weg? Dazu werden hier zwei verschiedene Methoden diskutiert, die unterschiedliche
Aufgaben haben. Steering berechnet den optimalen Weg in kleinen Räumen und Maps,
während der A*-Algorithmus in der Regel für große Landschaften benutzt wird [1].
2.1 Bewegen von NPCs
Hierbei sind zwei Problemszenarien denkbar, die gelöst werden müssen.
1) Das Bewegen in Landschaften und großen Räumen:
Bewegung auf der gesamten Karte, d.h. Levelmap übergreifend.
2) Die Orientierung in kleinen Räumen:
Bewegungen auf dem Spiellevel (also in einer Levelmap)
2.1.1 Intelligente Bewegung der Agenten durch das Gelände
2.1.1.1 A*-Algorithmus
Um Agenten zielsicher auf dem kürzesten Weg durch das Gelände zu schicken, bedient man
sich in der Regel des A*-Algorithmus’. Dieser Algorithmus basiert auf „Djikstras-Shortest-
Path“-Algorithmus und berechnet mit Hilfe einer zusätzlichen Abschätzungsfunktion h den
kürzesten Pfad zwischen zwei Knoten.
Hierfür werden sowohl Wegpunkte (Knoten) als auch Verbindungen (Kanten) zwischen den
benachbarten Wegpunkten benötigt, um die möglichen Laufwege der Map abzubilden.
Diese Knoten und Kanten definieren einen Graphen, welcher mögliche Pfade zwischen
Regionen und Knoten der Karte repräsentiert.
Der A*-Algorithmus versucht nun mit Angabe des Start- und Zielknotens den kürzesten Weg
entlang der Knoten zu finden. Dazu werden zuerst alle vom Startknoten aus direkt
erreichbaren Knoten anhand der Formel f(n) = g(n) + h(n) in einer sogenannten „openlist“-Liste sortiert, wobei n der n-te Knoten ist, der betrachtet wird. g(n) ist die kürzeste Strecke
zwischen dem Startknoten und dem Knoten n. h(n) ist die abgeschätze Entfernung vom
Knoten n zum Zielknoten, wobei h(n) kleiner oder gleich der Entfernung zu einem direkt
erreichbaren Nachbarknoten sein muss.
Nun wird in jedem Schritt der Knoten mit dem kleinsten f(n) in die „closedlist“-Liste
verschoben und die „openlist“ wird neu berechnet. Dazu werden alle von Knoten n direkt
erreichbaren Knoten in die „openlist“ hinzugefügt. Ist der neue Knoten schon in dieser Liste
enthalten, wird f(n) neu berechnet. Dieser Algorithmus wird so oft wiederholt, bis der
Zielknoten in der „closedlist“ enthalten ist. Anhand dieser „closedlist“ kann der Algorithmus
dann einen Pfad mit minimaler Länge vom Start- zum Zielknoten konstruieren.
Abbildung 2.1.1.1.a: Beispiel eines Schrittes beim A*-Algorithmus’
Aufgrund der Abschätzungsfunktion h, die bei jedem Schritt gegebenenfalls neu berechnet
werden muss, ist A* nur für große Maps geeignet. Denn bei kleinen Maps, wie
beispielsweise Levelmaps, könnte der berechnete Weg verworfen werden, sobald sich die
Spielsituation ändert. Dies könnte z.B. dann eintreten, wenn ein plötzliches Hindernis den
berechneten Weg versperrt. Dies geschieht bei Levelmaps häufig, so dass die
Berechnungen immer wieder von vorne beginnen müssten – und das auf Kosten der
Rechenzeit. Daher benutzt man A* um sich grob im großen statischen Terrain bewegen zu
können.Was passiert aber, wenn man sich zwischen zwei Wegpunkten von A* bewegt und plötzliche Hindernisse den berechneten Weg versperren? Solche Szenarien sind typsich für kleine Levels. Daher werden für diese dynamischeren Levels eine andere Technik benötigt: die so genannten Steering-Technik. 2.1.1.2 Steering Unter Steering versteht man das Bewegen zwischen zwei Wegpunkten der großen Map (die zum Beispiel von A* berechnet wurden). Steering-Methoden eignen sich nur für eingeschränkte Perspektiven (Zimmer, Gebäude, usw.). Die Implementierung erfolgt meist durch die Berechnung von Vektoren, welche alle relevanten Informationen für die Fortbewegung beinhalten (Geschwindigkeitsvektor, Richtungsvektor, usw.). Diese Vektoren werden anschließend zu einem „Final“-Vektor zusammengefasst, der dann z.B. als neuer Richtungsvektor für den Agenten dient. Beispiel: Es wird ein Vektor berechnet, der die momentane Richtung des Agenten repräsentiert. Ein Hinderniss, das sich auf dem Weg des Agenten befindet, kann dann mit einem Vektor repräsentiert werden, der orthogonal zum Vektor des Agenten steht. Mit einer einfachen Vektoraddition hätte man dann einen neuen Vektor, der als neuer Richtungsvektor für den Agenten fungieren kann. Auf diese Weise kann er das Hinderniss umgehen (siehe Abbildung 2.1.1.2.a).
Da nun die Bewegung der NPCs im Raum verdeutlicht worden ist, soll nachfolgend erläutert
werden, wie Agenten gezwungen werden können, sich zu entscheiden.
Abbildung 2.1.1.2.a: Beispiel eines Final-Vector beim Steering
2.2 Entscheidungen von NPCs
Auch hinsichtlich des Entscheidungsverhaltens der Agenten stehen zwei Techniken zur
Verfügung.
1) Endliche Automaten
2) Entscheidungsbäume
Die häufigste Realisierungsmethode ist das Konzept der endlichen Automaten. Der Grund
für ihren häufigen Einsatz innerhalb der KI ist ihre Mächtigkeit und vor allen Dingen ihre
Effizienz und Übersichtlichkeit. Umgesetzt wird dieses Konzept in einfachen If-Then-
Statements, was dazu führt, dass es sich hier nur um ein Designkonzept handelt, da keine
Automateninterpreter zum Einsatz kommen.
Das andere Konzept, ist das Konzept der Entscheidungsbäume, welches hierbei auch nur
als ein Designkonzept zu verstehen ist, bei dem Testbedingungen die Knoten des Baumes
repräsentieren.Endliche Automaten sind ein einfaches aber sehr mächtiges Konzept der Informatik. Dieses Konzept haben auch KI Designer für sich entdeckt, damit aber gleichzeitig auch eine Möglichkeit gefunden, ihre Ideen Informatikern verständlich zu machen. Denn spätestens bei der Programmierung von Agenten muss das Know-How beider Disziplinen vereint und das Problem gelöst werden, wie man die verschiedenen Konzepte vermittelt. 2.3 Programmierung von Agenten Bei der Entwicklung der künstlichen Intelligenz von Spielen arbeiten KI-Designer und Programmierer zusammen, was zwangsläufig oft zu Verständnis- und Kommunikationsproblemen führt. Auf der einen Seite sind KI-Designer keine Programmierer, kennen folglich also nicht die programmiertechnischen Grenzen. Andererseits besitzen Programmierer wenig oder gar kein Wissen über die zugrunde liegenden KI-Konzepte. Hierbei wird deutlich, dass die Notwendigkeit besteht, den Programmierern das KI-Design zu vermitteln. Als eine Möglichkeit dieser Vermittlung gelten UML ähnliche, GUI basierte Tools, die endliche Automaten modellieren [2]. Anhand der Automatentheorie kann das KI-Konzept anschaulich erläutert und visuell aufgezeigt werden. Dafür werden verschiedene Komponenten definiert: 1) Maschinen 2) Zustände (abgerundetes Rechteck) 3) Übergänge (Linie mit der Bedingung in der Mitte) 4) Bedingung (Kreis, kann beinhalten boolean, range, contains, ≤, ≥, , =) 5) Input und Events (Rechteck, Inputs von außen an die Maschine) 6) Aktion (ausgeführter Codeblock in geschweiften Klammern)
Abbildung 2.3.a: Beispiel eines Automaten Abbildung 2.3.a zeigt einen Automaten der sich mit dem Gesundheitszustand eines Agenten befasst. Der Ausgangszustand ist der „HEALTHY“ Zustand, der durch eine Situation des Spiels verändert wurde (Verletzung des Agenten). Damit wäre die Bedingung „LOW HEALTH“ erfüllt und der Automat geht in den neuen Zustand „UNHEALTHY“ über. In diesem Zustand wird ein Codeblock ausgeführt (wie zum Beispiel essen, schlafen, trinken o.ä.), um wieder zum Ausgangszustand gelangen zu können. Wenn der Gesundheitszustand wieder erreicht wurde, ist die Bedingung „HEALED“ wieder erfüllt und der Automat geht in den Defaultzustand „HEALTHY“ zurück. Nachdem so ein Verhaltensmodell als Automat erzeugt wurde, kann aus ihm sehr leicht ein Programmiercode generiert werden, der leicht ins Hauptprogramm eingebunden werden kann. Da sich intelligente Agenten sich nicht nur durch eigene Entscheidungen auszeichnen, sondern auch durch die Fähigkeit Spielzüge des menschlichen Gegners vorherzusagen, soll im Folgenden betrachtet werden, wie NPCs Vorhersagen treffen.
2.4 Vorhersagen von NPCs
Die hier besprochene Technik zur Vorhersage von Spielzügen beruht auf dem statistischen
N-Gramm-Modell.
2.4.1 N-Gramm-Modell
Aus programmiertechnischer Sicht handelt es sich bei N-Gramm-Modellen um
n-dimensionale Arrays, wobei die Stellen 1 bis (N-1) die letzten Spielzüge beinhalten [4].
Position N ist eine Tabelle mit den Wahrscheinlichkeiten des nächsten Zuges.
Dabei stellt sich allerdings die Frage, wie die Wahrscheinlichkeiten berechnet werden.
Um die Wahrscheinlichkeiten des n-Knotens zu berechnen verwendet man folgende
Formeln:
#(an-1,an)
mit Bigrammen (N=2): P(an | an-1) = #(an-1)
mit Trigrammen (N=3): P(an | an-2, an-1) = #(an-2, an-1, an)
#(an-2, an-1)
Wie man an der Formel für die Trigramwahrscheinlichkeit sieht, benötigt sie Bigramme und
Trigramme.
N-Gramme können jedoch auch als Graphen dargestellt werden.
Abbildung 2.4.1.a: Beispiel N-Gramm als GraphAbbildung 2.4.1.b: Beispiel eines Bigramms
Beispiel Bigramm: Aus der Tabelle 2.4.1.b kann man nun die Werte für die Berechnung der
Wahrscheinlichkeiten ablesen. So trat die Kombination a2, a2 genau drei mal und a2 ,a1 sechs
mal im Trainingskorpus auf. Möchte man nun wissen, wie hoch die Wahrscheinlichkeit ist,
dass a2 als nächste Aktion auftritt, nachdem a2 schon als (n-1)-te Aktion vorliegt.
#(a2,a2) 3 1
Mit der Formel wäre die Wahrscheinlichkeit P(a2 | a2) = = =
#(a2) 12 4
Das bedeutet, dass mit einer Wahrscheinlichkeit von 25% a2 nach a2 folgen würde.
2.4.1.1 Einsatz von N-Grammen zur Vorhersage
Um N-Gramme zu verwenden, muss man beachten, dass sie einigen lokalen
Einschränkungen unterliegen. Diese können beispielsweise sein:
1. Spielewelt-Constraints: Erst nachladen, dann schießen.
2. Player Styles: Bevorzugte (Schlag-)Techniken (z.B. Tekken). Dadurch kommen
einige Kombinationen selten vor.
3. Bonus: Bestimmte Schläge erhält man erst nach einer bestimmten Sequenz.
4. Spielkontrolle: Einige Moves und Kombinationen sind aufgrund der Anordnung der
Buttons am Controller einfacher und andere schwerer.2.4.1.2 Wieso werden N-Gramme verwendet?
Das programmieren von N-Grammen ist durch die Verwendung von einem Array relativ
einfach. Diese Form der Implementierung ist jedoch bei höherer Ordnung unbrauchbar
(N≥ 4), da der Speicherverbrauch bei O(MN) liegt, wobei M die Anzahl der möglichen Moves
in einem Spiel ist [4].
Dies liegt daran, weil das Array durch viele 0-Einträge schwach besetzt wäre, der Speicher
aber dennoch dafür reserviert wird. Die einzige Lösung dieses Problems besteht darin, N so
klein wie möglich zu halten. Aber selbst in diesem Fall hat man immer noch das Problem des
kleinen Trainingkorpus’, da dieser endlich ist.
Bei einem endlichen Trainingskorpus werden valide Sequenzen unterschlagen, weil die
Testspieler diese nicht gespielt haben. Dadurch erhalten andere Sequenzen eine höhere
Wahrscheinlichkeit. Hierbei handelt es sich um das sog. Sparse-Data-Problem, für welches
zwei Lösungsansätze vorhanden sind:
1) Threshholding
2) Gewichtete Summe über N-Gramme
Beim Tresholding werden einfach bestimmte Werte, die einen beliebigen Grenzwert nicht
überschreiten, ignoriert und durch einen „rare-event“ ersetzt.
Bei gewichteten Summen berechnet man die Wahrscheinlichkeit über eine Formel:
Wahrscheinlichkeiten über Bigramme:
P(an|an-2, an-1) = λ0*P(an) + λ1*P(an|an-1)+ λ2*P(an|an-2, an-1)
mit ∑ λi = 1
Auf diese Weise versucht man die Stärken der einzelnen N-Gramme zu „verschmelzen“.
Denn Trigramme sind genauer bei richtigen Werten, bei einem Fehlschlag ist der
Unterschied allerdings viel stärker. Bigramme sind zwar nicht so genau, aber dafür robuster.
Unigramme sind lediglich die absoluten Wahrscheinlichkeiten von Vorkommnissen eines
Spielzuges.2.4.1.3 Training von N-Grammen
Das Training von N und (N-1)-Grammen ist simpel. Dafür werden lediglich Spielzüge von
Testspielern der Länge N gezählt, in einem Array abgespeichert und später in
Wahrscheinlichkeiten ausgedrückt (siehe Beispiel 2.4.1.b).
Der Trainingsmodus wird mit möglichst vielen Spielern wiederholt, um einen breit gestreuten
Trainingskorpus zu erhalten. Als Faustregel für einen ausreichend großen Trainingskorpus
gilt:
C = k*MN-1
K: konstanter Wert zwischen 10 und 25
M: erlaubte Moves
N: Rang des N-Gramms
Das Anpassen von N-Grammen an verschiedene Spieler gestaltet sich ebenfalls sehr
simpel. Der Trainingsalgorithmus wird hierbei einfach mit den Spielen des Spielers neu
gestartet. Der Trainingskorpus mit der Faustregel ermöglicht allerdings bereits, dass man
schon relativ gute Gegner erhält, welche den meisten Spielern genügen.
2.4.1.4 Benutzung von N-Grammen
Die einfachste Methode der N-Gramm-Nutzung ist die deterministische Variante. Es wird
derjenige Eintrag gewählt, der die höchste Wahrscheinlichkeit besitzt.
Bei der probabilistischen Methode wird eine Zufallszahl generiert und der Eintrag gewählt,
der zu dieser probabilistischen Streuung gehört.
Beispiel: Seien 0.3, 0.6, 0.1 drei Wahrscheinlichkeiten, die zu drei verschiedenen
Ereignissesn gehören. Statt dieser Wahrscheinlichkeiten speichert man 0.3, 0.9 und 1.0.
Jetzt „würfelt“ man eine Zufallszahl zwischen 0.0 und 1.0. Anschließend wählt man einfach
das erste Ereignis aus, deren gespeicherten probabilistischen Streuung kleiner als die
Zufallszahl ist.
Mit N-Grammen ist es demnach also möglich, menschliche Züge nachzuahmen und auch
vorherzusagen. Und das mit nur geringen Laufzeitkosten.Dies bedeutet jedoch gleichzeitig auch Nachteile von N-Grammen: Sie sind für die
Langzeitplanung ungeeignet. Zudem ist nach wie vor noch eine Anpassung an den Spieler
erforderlich.
2.5 Lernen von NPCs
Um Agenten das „Lernen“ beizubringen, sollte man beachten, dass Lernen nicht immer
gleich Lernen ist. Denn verschiedene Agenten haben verschiedene Aufgaben. Das Erfüllen
der unterschiedlichen Aufgaben setzt eine Unterscheidung bezüglich der Lernform voraus.
Anhand des Spiels „Black & White“ soll verdeutlicht werden, wie solche flexible Agenten
trainiert werden.
Um die verschiedenen Agenten (Bauer, Ritter) zu trainieren hat man verschiedene
Lernstrategien:
1) Lernen von Fakten:
Agent lernt: Städte befinden sich bei Nahrungsquellen.
2) Dominanz von Desires:
Wann soll ein Agent friedlich sein und wann nicht?
Energie „aufladen“ ist wichtiger als den Kampf fortzusetzen
3) Welche Objekte befriedigen welche Bedürfnisse?
Was darf der Agent Essen?
4) Lernen durch Feedback:
Bestrafen oder Belohnen des Agenten.
5) Lernen durch Beobachten:
Agent beobachtet, leitet daraus Ziele ab und lernt die Handlung.
6) Lernen durch Befehl:
Agent lernt durch direkte Befehle.
Um die verschiedenen Lernmethoden zu realisieren, hat man die Belief-Desire-Intention-
Architektur (BDI) entwickelt, welche anschließend um die Kategorie der Opinions erweitert
wurde [3].Mit Hilfe der drei Kategorien – Belief, Desire und Opinion – wird die Intention generiert,
welche wiederum in Pläne und Handlungen umgesetzt wird.
Die einzelnen Kategorien subsumieren unterschiedliche Inhalte.
1) Beliefs:
Beliefs speichern Informationen über Objekte und bestimmte Fakten ab. Wie z.B.
„Steine kann man nicht essen“ usw. Sie können jedoch ausschließlich Informationen
über bereits „erfahrene“ Objekte sammeln.
2) Desires:
Desires repräsentieren Bedürfnisse. Diese haben jeweils zu verschiedenen
Zeitpukten unterschiedliche Intensität. Jedes Desire hat unterschiedliche „Desire-
sources“, welche zur aktuellen Intensität beitragen.
Eine Kreatur kann beispielsweise verschiedene Gründe haben, aus denen es Hunger
verspürt. Dieser kann daher durch das Sehen eines als schmackhaft empfundenen
Nahrungsmittels hervorgerufen werden, Folge eines niedrigen Energiestandes oder
auch Trauer sein. Diese drei „Desire-sources“ dienen als Input für ein Perzeptron.
Durch Training kann man die Gewichte des Perzeptrons derart verändern, dass
persönlich bevorzugte Kreaturen entstehen, wie z.B. eine Kreatur, die immer fressen
will, eine die nur frisst, wenn sie sich traurig fühlt oder wenn sie am verhungern ist
(siehe Abbildung 2.5.a).
Abbildung 2.5.a: Beispiel eine Perzeptrons3) Opinions:
Opinions werden benötigt um Pläne zu erstellen. In ihnen wird festgehalten, welches
Objekt, welche Bedürfnisse am Besten befriedigt. Z.B. Wasser stillt den Durst.
Diese unterschiedlichen Kategorien werden in verschiedenen Datenstrukturen dargestellt:
Die Darstellung der Beliefs erfolgt über einfache Listen mit Attribut-Wert-Paaren, die
bestimmte Objekte repräsentieren.
Opinions werden in Form von Entscheidungsbäumen und Intentionsplänen dargestellt.
Desires sind als Neuronen repräsentiert.
Hierbei verläuft die Verhaltensplanung durch den Agenten folgendermaßen:
Für jedes aktive Desire durchläuft der Agent seine brauchbaren Beliefs und wählt daraus
denjenigen mit der besten Opinion aus. Anschließend wird für jedes Ziel ein Plan erstellt und
derjenige mit dem höchsten Nutzwert ausgewählt, welcher anhand der Formel
utility(desire, object) = intensity(desire) * opinion(desire, object)
berechnet wird.
2.5.1 Verschiedene Lernmethoden
2.5.1.1 Lernen durch Entscheidungsbäume
Beim Lernen durch Entscheidungsbäume werden Informationen von Außen benötigt [3].
Diese können entweder vom Spieler oder von der Spielwelt ausgehend an den Agenten
weitergegeben werden. Sie werden danach im Langzeitspeicher als Beliefs abgespeichert.
Das Verschmelzen von Desires und Opinions ermöglicht den Agenten eine Veränderung
ihrer Persönlichkeit, um sich somit ihrem Meister anpassen zu können.
Genau dies geschieht beim „Lernen durch Entscheidungsbäume“. Infolge einer Aktion erhält
der Agent eine Form von Feedback, die ihm sagt, ob die vollzogene Handlung in dieser
Situation gut oder schlecht war.
Wie lernt ein Agent nun aber konkret z.B. welche Dinge essbar sind und welche nicht?
Hierzu blickt er auf die gesammelten Erfahrungen und das dazugehörige Feedback
hinsichtlich des gegessenen Objektes und dessen Essbarkeit. Mit Hilfe der Generierungeines Entscheidungsbaums versucht der Agent herauszufinden, welche Daten einen Sinn
ergeben.
Der ID3-Algorithmus generiert einen „schönen“ Baum aus der Erfahrungstabelle, indem er
die Entropie minimiert. Unter Entropie versteht man ein Maß, welches angibt, wie zufällig
oder gezielt ein Feedback war.
2.5.1.2 Training von Desires
Desires werden als Neuronen modelliert (siehe Abbilund 2.5.a). Neuronen sind eine
Ansammlung von Inputs („desire-sources“) und deren Gewichten.
Neuronales Training besteht darin, die Gewichte derart zu verändern, dass die Kreaturen
sich wie gewünscht verhalten.
Bei N Inputs x1,…, xn und N Gewichte w1,…, wn
Intensity = 1 if ∑ wi*x i > 0.5 and 0 otherwise
Die Gewichte werden verändert durch
wi wi + ∆wi
mit
∆wi = η * (intended value – actual value) * xi
verändert.
(η ist dabei die Lerngeschwindigtkeit, die meist klein gewählt wird)
2.5.1.3 Nachteile des Lernens durch Feedback
Das Lernen durch Feedback wirkt für den Spieler unrealistisch, da immer ein offensichtlicher
Input erfolgen muss (Feedback). In der Realität wird auch nicht immer nur durch die
Unterscheidung zwischen „Gut“ und „Böse“ gelehrt, sondern auch durch Vormachen und
Zeigen.
Darüber hinaus kann es Frust erzeugen, da der Spieler immer warten muss, bis der Agent
seine Aktion beendet hat, um ihn beurteilen zu können.Zusätzlich kann es zu Lernfallen kommen, wenn der Agent ein Feedback des Spielers falsch interpretiert oder es durch Versehen des Spielers zu falschen Feedbacks kam (schlechte Steuerung des Spiels, falsche Taste gedrückt). In solchen Situationen kann der Spieler den Agenten nicht mehr dazu bewegen, eine doch gewünschte Aktion zu wiederholen, wenn sie zuvor als „schlecht“ bewertet worden ist. In derartigen Situationen muss der Agent sozusagen „erfühlen“, was sein Meister von ihm erwartet hat. Dies beinhaltet, dass die Lernsituation eventuell wiederholt oder auf andere Situationen übertragen werden muss. Der einfachste Weg solch eine Empathie zu simulieren ist eine Tabelle, in der festgehalten wird, welche Aktion in welcher Situation durchgeführt wurde. Durch Vergleiche ist der Agent folglich imstande auf Aktionen in bestimmten Situationen zu schließen. Da vorhergehend Techniken zur Modellierung und die Möglichkeiten des Lernens von Non- Personal-Characters skizziert wurden, soll im Folgenden die Frage des Programmierens geklärt werden. 3 Konklusion 3.1 KI-Forschung vs. KI in Spielen Es gilt als Traum, dass die traditionelle KI-Forschung das Material für die Spieleentwickler liefert, die dann mit leichter Anpassung sofort Einsatzbereit wäre. Die Wirklichkeit der Zusammenarbeit zwischen der KI-Forschung an den Universitäten und den Spieleherstellern fällt leider nüchterner aus: Die Erkenntnisse der KI-Forschung sind für die Spieleindustrie leider viel zu oft unbrauchbar, da die Umsetzung aufgrund der zusätzlich eigenen Entwicklung, Tests und Anpassung zu teuer wäre. Dennoch werden viele Erkenntnisse und Algorithmen der KI-Forschung angepasst und verwendet (z.B.: A*-Algorithmus, neuronale Netzwerke, Automatentheorie, usw.) Eine erschwerte Zusammenarbeit entsteht allerdings nicht nur durch die ökonomischen Nachteile. Die reservierte Haltung der KI-Forscher gegenüber dem Einsatzfeld der Computerspiele trägt ebenfalls zu der geringen Kooperation bei.
Dies ändert sich jedoch aufgrund des wachsenden Spielemarktes und der zunehmenden Komplexität der Spiele. 3.2 Zukünftige Entwicklung In naher Zukunft besteht die Möglichkeit einige Probleme der heutigen KI (z.B. fehlende CPU-Zeit) durch die steigende CPU-Power und bessere Hardware zu lösen. Demzufolge können immer bessere NPCs entwickelt und die unnatürlichen KI-Cheats können reduziert werden. Darüber hinaus bleiben jedoch noch eine Menge Probleme erhalten, welche es zu lösen gilt. Das Problem des zu großen Spektrums – d.h. dass eigentlich alle Agenten (nicht nur die sichtbaren) gesteuert und berechnet werden müssten – wird wohl auch in ferner Zukunft noch ungelöst bleiben. Dies liegt darin begründet, dass die Anzahl der NPCs in Spielen stetig steigen wird. Dennoch ist der heutige Trend deutlich sichtbar: Es geht um die Optimierung des Spielspaßes und des Spielerlebnisses. Agenten sollen den menschlichen Gegner herausfordern und ihm lang anhaltenden Spielspaß garantieren. Dies wird beispielsweise mit Hilfe komplett simulierter Städte und Zivilisationen sowie tiefere NPC-Charaktere realisiert. Abschließend ist zu sagen, dass Spiele wie „Fear“ bereits in die angestrebte Richtung gehen. Dort werden die im Raum befindlichen Gegenstände oder Zimmerecken als Deckung genutzt, so dass der Spieler nicht mehr mit wild umherschießenden, unkoordinierten und berechenbaren Gegnern konfrontiert ist. Denn ihm geht es nicht ausschließlich ums Gewinnen, sondern um die möglichst realistische Herausforderung! 3.3 Zusammenfassung Die Spieleindustrie ist ein immer weiter anwachsender Markt mit einem großen wirtschaftlichen Potenzial. Um dieses Potenzial richtig ausschöpfen zu können, bedarf es großer Spielehits die überzeugen. Neben der aufwendigen Grafik, einer realistischen Physikengine ist die KI in den Spielen, ein nicht mehr wegzudenkender Faktor geworden. Das haben die Spieleentwickler gemerkt und setzten mittlerweile immer mehr auf eine ausgeklügelte KI, die langanhaltenden Spielespaß garantieren.
Um ihre KI umzusetzen, erfinden Hersteller entwerder neue Techniken oder übernehmen sie aus der KI Forschung. Einige der eingesetzen Techniken und die damit verfolgten Ziele wurden hier vorgestellt und erläutert. Dazu gehören z.B. die Steering-Technik und der A*-Algorithmus, die für das Bewegen der Agenten in großen und kleinen Areale verantworlich sind. Zu den Erfindungen gehören Tools, wie das hier vorgestellte, um die Arbeitsschritte und Zusammenarbeit zwischen KI-Designern und Programmieren zu vereinfachen. Mit diesen UML ähnlichen Tools können Verhaltensweisen von Agenten als Automaten modelliert werden, so dass aus den designten Automaten dann einfach Programmiercode automatisch erzeugt werden kann, der sich dann einfach in den restlichen Programmcode einfügen lässt. Ausserdem wurde gezeigt, wie Agenten Vorhersagen mit Hilfe von N-Grammen machen können. Anschließend wurde am Spiel „Black & White“ aufgezeigt, wie man auch Perzeptrone und Entscheidungsbäume nutzen kann, um Agenten individuell zu trainieren, damit sie später verschiedene Aufgaben nach den Vorstellungen des „Meisters“ (Spielers) meistern. Abschließend ist zu erwähnen, dass die Spielewelt für die konventionelle KI-Forschung ein interessantes Einsatzgebiet geworden ist, so dass es langfristig zu einer Annäherung kommen wird. Es bleibt zu hoffen, dass durch diese Annäherung Spiele noch interessanter werden, weil die Spieleindustrie von den aktuellen KI-Forschungen schneller profitieren. Denn heute dauert es noch zulange, bis Erkenntnisse und Entdeckungen der KI-Forschung den Weg in die Spieleindustrie finden, weil die Anpassung und das Testen der neuen Techniken aus der Forschung noch zu teuer und aufwendig ist.
4 LITERATUR
1. Nareyek, A.: Artifical Intelligence in Computer Games – State of the Art and
Future Directions 2004, ACM Queue 1(10), 58-65
2. Carlisle Phil (Team17 Software Ltd): Designing a GUI Tool to Aid in the
Development of Finite-State: In: Rabin, S.,
(ed.) AI Game Programming Wisdom, (2002), Section 2.5
3. Evans, R. (Lionhead Studios): Varities of Learning: In: Rabin, S., (ed.) AI
Game Programming Wisdom, (2002), Section 11.2
4. Laramée D. F.: Using N-Gram Statistical Models to Predict Player Behavior:
In: Rabin, S., (ed.) AI Game Programming Wisdom, (2002), Section 11.5:Sie können auch lesen
