Reborn hat Recht, aber das ist bei eigentlich allen Spielen der Fall das sich die KI an an den Menschen anpassen soll
. Man sollte sich aber schon überlegen ob es Sinn macht mit dem Hammer auf eine Mücke zu schlagen.
....
hmmmn ich könnte mal nach den Prüfungen ein Tutorial dazu schreiben, ... das würde dann aber noch so ca. 3 Wochen dauern..., meist ist dazu nur ganz harte Mathematik im Netz zu finden, mit der man natürlich sowas machen kann.
Das Problem bei deinem konkrten Fall wird wohl sein das die Spielregeln ja unumstößlich sind, du musst also so was wie einen "Überwacher" dazu coden, der einen sehr negativen Input dem Netz gibt, damit es merkt das es in solche Zustände nicht kommen darf. (Wie bei einem kleinen Kind eben
). Ich weiss nicht ob es möglich ist ein Netz so von vornherein anzulernen, das es nie wieder in solche Zustände kommt, da muss ich mal fragen...
o Für deinen Konkreten Fall würde ich ein
Hebbsches Netz mit Perzeptron Lernalgorithmus (
nicht Hebbsches Lernen nehmen, da du mit Hebbschen Lernen nur 0.14*n Muster anlernen klannst, ohne das das Netz komische Dinge tut). n bezeichne Dabei die Anzahl der "Neuronen". Mit dem Netz oben erreichst du zumindest keine Frusttration bei 2n Mustern.
o Ein weiterer Kandidat wäre das
Back Error Propagation lernen. Dazu hab ich auch einen Algorithmus und sogar ein Octave Script, falls du magst. Dann brauchst du nicht so lang warten
.
Empfehlenswerte Litheratur und Links
http://www.neuronalesnetz.de/
http://www.dkriesel.com/index.php?id=neuronalenetze
Das PDF "Neuronale Netze" ist sehr gelungen, hab darin auch schon gelesen, manche Notationen sind etwas anders als im folgenden Algorithmus, für Error Back Propagation Lernen, aber ich glaub mit etwas gutem Willen kommt man damit klar...
Error Back Propagation Lernen
--------------------------------------------
Geplänkel
Wir haben ein voll vernetztes Netz, jedes Neuron i hat mit einem anderen Neuron j der nächsten Schicht eine Verbindung, wenn unsere Gewichte wij den Wert 0 annehmen, dann exestiert quasi keine Verbindung. Ein negativer Gewischtswert wij wirkt sich hämmend, ein positiver verstärkend auf das Neuron i aus. Jedes Neuron hat m Verbindungen zu anderen Neuronen und einen eigenen Schwellwert bi mit dem es feuert.
Als "Ausgabefunktion" benutzen wir die Heavyside Funktion (um das Netz besser zu machen ist eine Sigmoide Funktion angebrachter)
Sei H(x) unsere sigmoide Funtion:
|
Quellcode
|
1
|
H(x) = 1/(1 + e^(-x))
|
Sei H'(x) unsere Ableitung für die sigmoide Funtion:
|
|
Quellcode
|
1
2
|
H'(x) = 1/(1 + e^(-x))² * e^(-x)
= H(x)² * e^(-x)
|
Bei der zweiten = - Zeichen würd ich dich bitte, das mal zu testen, ... hab ich mir gerade mal so ausgedacht
thx
Zu der Definition der Variablen und prinzipieller Aufbau:
o Wir haben ein
m-schichtiges
Feed Forward Netz (Es gibt also keine Rückkopplungen)
o Weiterhin gebe
n(s) Die Anzahl der Neuronen in Schicht s an.
o Mit yi(s) bezeichnen wir den Output des Neurons i der Schicht s
o wij(a), b(a) bezeichnen Gewichte und den Schwellwert des Neurons a
Das Netz soll das Muster x' € (R^n)in Klassen k € K unterteilen. x' ist dabei eine Matrix, deren Zeilen einem Muster entsprechen. Die Zeilen bezeichnen wir mit x(p) wobei p die p-te Zeile der Matrix meint. K ist eine Menge von Klassifikationen, einfachster Fall: K = {1, 2, 3, ... , n }.
Wir lernen das Netz mit deiner Lernstichprobe T = { (x(1), k1), (x(2), k2), ..., (x(n), kn) } an. Ein Tupel (x(n), kn) heisst dabei, das das Muster x(n) zu der Klasse kn € K gehört.
Unser Netz braucht |K| Neuronen in der Outputschicht (im allgemeinen die letzte Schicht), damit unser Netz auch die Klassifikation korrekt vornehmen kann. Klassifikation sollte hier allgemeiner betrachtet werden, auch dein Problem kann man mit Klassifikation lösen.
Der eigentliche Algorithmus
|
|
Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
o Initialisiere Schwellwerte und Gewichte für jedes Neuron i in jeder Schicht s. (z.B. randomisieren)
o Wähle ein Muster (x', k), aus T und setze alle Inputs der Input Schicht auf yi(0) = xi für jeden einzelnen Wert aus dem Vektor x'. D.h. die Input Schicht muss auch so groß sein wie die Länge des Mustervektors.
o Propagiere Signale durch das Netz mit:
yi(s) = H( SUM_j=1^n(s-1) (wij(s) * yj(s-1) + bi)) für alle Neurone i in jeder Schicht s.
Diese Funktion berechnet alle Outputs der Neurone im Netz. Man fängt bei der 1. Schicht (also eine Schicht tiefer der Inputschicht) an und geht bis zur Outputschicht weiter. Einfach mal an einer Skizze verdeutlichen, dann wird das glas klar.
o Berechne die Fehlerterme der Outputs
hi(s) = SUM_j=1^n(s-1) (wij(s) * yj(s-1) + bi)
Di(s) = 2*H'(hi(s)) * (ki - f(hi(s)))
o Propagiere Fehler zurück
Di(s-1) = H'(hi(s-1)) * SUM_j=1^n(s) Dj(s) * wji(s)
o Führe Lernschritt aus
DELTA_wij(s) = ALPHA *Di(s) * yj(s-1)
DELTA_bi(s) = ALPHA * bi(s)
wij_neu(s) = wij_alt + DELTA_wij(s)
ALPHA ist dabei die Schrittweite, diese sollte genügend klein sein, machs am Anfang einfach per Parameter einstellbar (so um 0.0014)
o Gehe zum Anfang, ziehe keinee 4000€ ein und wähle ein neues Muster aus T.
Bis sumarischer Fehler im Lokalen Minimum (gib einfach ein minimum vor ( < 0.00001 oder so)
|
, ich weiss aber nicht ob solche Programme schon offen verfügbar sind, auch auf den Lehrstuhl Seiten hab ich nichts dazu gefunden. 
20.05.2024, 17:45
Zum Seitenanfang
