[PYTHON] Machen wir Othellos KI mit Chainer-Teil 2-

Einführung

Dieser Artikel ist eine Fortsetzung von "Erstellen von Othello AI mit Chainer-Teil 1-". Wir hoffen, dass Sie den ersten Teil gelesen haben, bevor Sie diesen Artikel lesen.

• Teil 1

• Konvertierung von Lehrerdaten

• MLP Design

• Modellschulung und Lagerung

• Teil 2 (dieser Artikel)

• Implementierung in Othello-Spielen

• Überprüfen Sie, ob es spielbar ist (können Sie das Spiel spielen, ohne von den Regeln abzuweichen)

• Wenn Sie feststellen, dass es hier nicht spielbar ist, fahren Sie mit der Erstellung des MLP-Modells fort

Mit dem trainierten Modell, das im ersten Teil erstellt wurde, habe ich AI mit dem MLP-Modell im Othello-Spiel implementiert. Verwenden Sie für die Othello-Spiel-App die in "Lassen Sie uns Othello mit wxPython erstellen" erstellte App. Der Quellcode und die trainierten Modelle der Othello-Spiel-App sind auf GitHub aufgeführt. Bitte beziehen Sie sie von dort.

Beschreibung der Othello-Spiel-App

Dies ist eine App, die mit wxPython erstellt wurde. Es erfordert wxPython, um zu funktionieren. Die Installationsmethode finden Sie unter hier. Die Startmethode ist wie folgt.

$ python reversi.py

Ich werde den Bildschirm kurz erklären. Geben Sie das Modell für AI by MLP in "MLP-Modelleinstellung" ganz rechts an. Geben Sie das Modell für den ersten Zug (schwarz) in "für schwarz" und das Modell für den zweiten Zug (weiß) in "für weiß" an. Geben Sie in ähnlicher Weise die Computer-KI in der Einstellung "Computer-KI" ganz rechts an. Details der KI werden später beschrieben. Im leeren Bereich in der Mitte wird die Punktzahl im Verlauf des Spiels angezeigt. Stellen Sie den Spieltyp in der unteren Mitte auf "Spielmodus" und starten Sie das Spiel mit der Schaltfläche "START".

• Man vs Man

• Kampf von Mensch zu Mensch. Klicken Sie mit der linken Maustaste, um den Stein zu platzieren. Der erste Zug ist schwarz.

• Man vs Computer A

• Computer A vs Man

• Computer A gegen Mensch. Computer A ist der erste (schwarz).

• Computer A vs Computer B

• Konkurrieren Sie zwischen Computern.

"SCORE" in der unteren Mitte ist die aktuelle Anzahl der Steine im ersten (schwarz) und zweiten (weiß). Geben Sie die Anzahl der Loops in das Textfeld unten in der Mitte ein und drücken Sie die Taste "Comp vs Comp Loop", um Computer A und Computer B so oft hintereinander abzuspielen. (Verwenden Sie zu diesem Zeitpunkt nicht die Schaltfläche "START".) Am Ende der Schleife wird die Anzahl der Siege für Computer A und Computer B angezeigt. ZEICHNUNG ist die Anzahl der Ziehungen.

Diese Othello-App ermöglicht Ihnen nicht nur das Spielen regulärer Schlachten, sondern verfügt auch über die folgenden Funktionen.

1. Sie können Computer AI auswählen. (Weitere Informationen zu AI außer MLP finden Sie hier](http://qiita.com/kanlkan/items/cf902964b02179d73639))
   • MLP

• KI mit einem trainierten MLP-Modell. Dies ist Gegenstand der Überprüfung.
  • 1st Gain Max
• KI, die einen Bewertungswert auf dem Brett festlegt und an einer Stelle platziert, an der der Gesamtbewertungswert der Steine, die selbst genommen werden können, hoch ist.
  • Min Max 3
• KI, die mit der Min-Max-Methode dreimal vorausliest. Aber sehr schwach. Vielleicht stimmt etwas nicht.
  • Random
• KI, die es zufällig an einem Ort platziert, an dem es platziert werden kann.

1. Wenn KI mit dem MLP-Modell ausgewählt ist und KI eine von den Regeln abweichende Bewegung auswählt, wird "* Illegale Bewegung! ... *" an die Standardfehlerausgabe ausgegeben. Die Typen sind wie folgt. ** Wenn ein illegaler Zug auftritt, wird die Hand des Computers an die erste Stelle im Stein gelegt, wenn sie platziert werden kann, und wenn es notwendig ist, zu passen, passen Sie sie und setzen Sie das Spiel fort. Masu (Fail Safe). ** ** **
   • Cannot put stone but AI cannot select 'PASS'.

• Ich konnte PASS nicht auswählen, obwohl ich keinen Platz zum Ablegen von Steinen hatte.
  • Cannot 'PASS' this turn but AI selected it.
• Ich habe PASS gewählt, obwohl ich nicht passen konnte (es gab einen Platz, an dem ich es platzieren konnte).
  • Cannot put stone at AI selected postion.
• Sie haben einen Ort ausgewählt, an dem Sie keine Steine platzieren können.

1. Sie können die Gewinne und Verluste zählen, indem Sie mehrere Schlachten zwischen Computer-AIs hintereinander spielen.

• Der erste und der zweite Angriff jeder KI werden nach dem Zufallsprinzip entschieden.
• Speichern Sie die Punktzahl des Kampfes zwischen AIs als "* record.log *".
• Diese Punktzahl kann von "* build_mlp.py *" gelesen werden.

Überprüfen Sie die KI mit dem MLP-Modell

Lassen Sie uns nun überprüfen, ob es spielbar ist. Ich möchte wenn möglich eine starke KI machen. Daher trainierte das Modell nur mit der Spielpunktzahl des ersten (schwarzen) Gewinnspiels (* model_black_win.npz ) und das Modell trainierte nur mit der Spielpunktzahl des zweiten Spielers (weiß) ( model_white_win.npz). Lass uns mit *) gegen einen Menschen (mich) spielen. Hmmmm. .. .. ** Mumu **. ** Illegaler Zug! Es kam heraus ... ** Es war nicht so einfach wie beim Anordnen von drei Augen. Es liegt jedoch weiterhin im Rahmen der Erwartungen. Lassen Sie uns zunächst die Arten der auftretenden illegalen Bewegungen und ihre Häufigkeit untersuchen. Die Sonne geht unter, wenn Sie gegen sich selbst spielen. Spielen wir also gegeneinander. Ich werde gegen MLP und Random spielen. Illegale Bewegung! 7027 Mal in 1000 Schlachten aufgetreten. Die Aufteilung der Arten von illegalen Bewegungen ist wie folgt.

Grob berechnen. Unter der Annahme, dass in einem Spiel kein Pass generiert wird und das Brett erst abgerechnet werden kann, wenn es gefüllt ist, werden 60 Züge ausgeführt, bis das Brett gefüllt und abgerechnet ist. Ein Spieler trifft 30 Züge. 30.000 Züge in 1000 Schlachten. Da es sich also um 7027/30000 handelt, kann geschätzt werden, dass 23,4% der Fälle betrügerisch sind.

80% der Spiele werden gemäß den Regeln gespielt, daher mache ich mir Sorgen, die MLP-Konfiguration zu ändern ... Zunächst werde ich tun, was mir einfällt, ohne die Konfiguration von MLP zu ändern.

Das Try & Error Festival hat begonnen.

Wiederholen Sie 1: Versuchen Sie, die Punktzahl aller Spiele zu verwenden, nicht nur die Punktzahl des Gewinnspiels

Um eine starke KI zu schaffen, werde ich sie beiseite legen und der Einhaltung der Regeln Vorrang einräumen. Wir werden versuchen, die Vielfalt der Muster zu erhöhen, indem wir nicht nur die Spiele lernen, die gewonnen haben, sondern auch die Spiele, die verloren haben. Setzen Sie "* model_black.npz " für den ersten Zug (schwarz) und " model_white.npz *" für den zweiten Zug (weiß) als KI von MLP. Diese Modelle sind Modelle, die mit den folgenden Befehlen erstellt wurden.

$ python build_mlp.py Othello.01e4.ggf black
$ mv reversi_model.npz model_black.npz
$ python build_mlp.py Othello.01e4.ggf white
$ mv reversi_model.npz model_white.npz

Lassen Sie uns nun wie zuvor Computer gegeneinander spielen. MLP gegen zufälliger Rückkampf. Illegale Bewegung! 5720 Mal in 1000 Schlachten aufgetreten. Die Aufteilung ist wie folgt.

Da es 5720/30000 ist, ist es mit einer Rate von 19,1% illegal. Es scheint, dass die Zukunft noch lang ist, aber sie ist weniger als zuvor. Das ist ein guter Trend.

Wiederholen Sie 2: Versuchen Sie, die Anzahl der Epochen zu erhöhen, um von 1000 auf 3000 zu trainieren

Es ist ziemlich besiegt, aber wenn Sie öfter trainieren, wird es funktionieren. Ich habe "* build_mlp.py *" so geändert, dass batch_size und max epoch count als Argumente angegeben werden können, und das Modell mit batch_size = 100 und max_epoch_count = 3000 neu erstellt.

$ python build_mlp.py Othello.01e4.ggf black 100 3000
$ mv reversi_model.npz model_epoch-3000_black.npz
$ python build_mlp.py Othello.01e4.ggf white 100 3000
$ mv reversi_model.npz model_epoch-3000_white.npz

In meiner Umgebung dauerte dieses Lernen übrigens 5 Stunden + 5 Stunden = 10 Stunden ... Ich fürchte, ich habe nur eine Linux-Umgebung auf VirtualBox ...

Lassen Sie Computer mit diesen Modellen gegeneinander spielen. MLP gegen zufällige 1000 Schlachten.

Da es sich um 5966/30000 handelt, ist es mit einer Rate von 19,9% illegal. Es ändert sich nicht viel. Selbst wenn Sie die Epoche auf 1000 oder mehr erhöhen, scheint das Lernen nicht weiter zu gehen. Selbst wenn Sie es nicht mit Epoch auf 3000 versuchen, bereiten Sie ungefähr 1000 Testdaten, die den Lehrerdaten ähnlich sind, separat vor und verwenden Sie die Epoch-Accuracy-Korrelation (Lernkurve), wenn Sie "* build_mlp.py *" ausführen. Wenn Sie es sich ansehen, können Sie sehen, wie viel Epoche wahrscheinlich nicht weiter lernen wird.

Wiederholen Sie 3: Führen Sie 10000 Mal MLP gegen Random durch und verwenden Sie das auf dieser Punktzahl trainierte Modell

Selbst wenn die Lehrerdaten erstellt wurden, funktionieren sie nicht gut, daher werde ich einen anderen Ansatz ausprobieren. Richten Sie MLP AI mit "* model_black.npz ", " model_white.npz " ein und spielen Sie in MLP vs Random gegeneinander (diesmal 10000 Kämpfe). Ich werde versuchen, noch einmal mit dieser Punktzahl zu trainieren. Die Absicht ist, dass ich denke, dass es möglich ist, über Muster zu lernen, in denen MLP AI nicht gut ist, indem man eine Punktzahl verwendet, die die richtige Antwort mit der Fail Safe-Funktion für Muster gibt, in denen MLP AI nicht gut ist. Denn es ist. Lassen Sie uns zuerst 10000 MLP gegen Random spielen. Eine Score-Datei mit dem Namen " record.log " wird gespeichert. Benennen Sie sie daher in " mlp_vs_random_10000_01.log *" um. Lesen Sie diese Protokolldatei und erstellen Sie das Modell neu.

$ python build_mlp.py mlp_vs_random_10000_01.log black 100 1000
$ mv reversi_model.npz model_mlp_vs_random_black_01.npz
$ python build_mlp.py mlp_vs_random_10000_01.log white 100 1000
$ mv reversi_model.npz model_mlp_vs_random_white_01.npz

Rematch mit MLP vs Random unter Verwendung des neuen Modells (* model_mlp_vs_random_black_01.npz, model_mlp_vs_random_white_01.npz *). Illegaler Zug! 2794 Mal in 1000 Spielen aufgetreten. Die Aufteilung ist wie folgt.

Da es 2794/30000 ist, ist es mit einer Rate von 9,3% illegal. Hört sich gut an! Es ist ungefähr die Hälfte! Lassen Sie uns jetzt unser Bestes geben.

Diese Methode scheint zu funktionieren. Versuchen Sie daher die gleichen Schritte erneut. Verwenden Sie * model_mlp_vs_random_black_01.npz, model_mlp_vs_random_white_01.npz , um 10000 Mal in MLP vs Random zu spielen. Ändern Sie " record.log " in " mlp_vs_random_10000_02.log *" und erstellen Sie das Modell mit diesem Protokoll neu. Ich werde.

$ python build_mlp.py mlp_vs_random_10000_02.log black 100 1000
$ mv reversi_model.npz model_mlp_vs_random_black_02.npz
$ python build_mlp.py mlp_vs_random_10000_02.log white 100 1000
$ mv reversi_model.npz model_mlp_vs_random_white_02.npz

Rematch mit MLP vs Random unter Verwendung des neuen Modells (* model_mlp_vs_random_black_02.npz, model_mlp_vs_random_white_02.npz *). Illegaler Zug! 2561 Mal in 1000 Schlachten aufgetreten. Die Aufteilung ist wie folgt.

Da es 2399/30000 ist, sind 8,0% der Fälle betrügerisch. Hmmm ... sollte es als leichter Rückgang gesehen werden? Einmal wird diese Methode hier gestoppt.

Wiederholen Sie 4: Führen Sie MLP vs Random 10000 Mal durch, kombinieren Sie die Punktzahl mit Othell0.01e4.ggf und verwenden Sie das trainierte Modell.

$cat Othello.01e4 mlp_random_10000_01.log > 01e4_mlp_randomA_10000_01.ggf
$ python build_mlp.py 01e4_mlp_randomA_10000_01.ggf
 black 100 1000
$ mv reversi_model.npz model_01e4_mlp_vs_random_black_02.npz
$ python build_mlp.py 01e4_mlp_randomA_10000_01.ggf
 white 100 1000
$ mv reversi_model.npz model_01e4_mlp_vs_random_white_02.npz

Wie oben erwähnt, trainieren wir mit der vorhandenen Silbe "* Othello.01e4.ggf " und der in der vorherigen Stufe erstellten Silbe " mlp_random_10000_01.log *". Ich dachte, dass die Leistung verbessert werden würde, weil die Punktzahl vielfältiger wäre und eine Hand enthalten würde, die zu einem illegalen Zug werden würde.

Rematch mit MLP vs Random unter Verwendung des neuen Modells (* model_01e4_mlp_vs_random_black.npz, model_01e4_mlp_vs_random_white.npz *). Illegaler Zug! In 1000 Schlachten 3325 Mal aufgetreten. Die Aufteilung ist wie folgt.

Da es sich um 3325/30000 handelt, führen wir betrügerische Handlungen mit einer Rate von 11,1% durch. Nun, das Ergebnis unterscheidet sich nicht wesentlich von Retry 3. Es tut uns leid.

Zwischenübersicht

Diese Woche werde ich es hier zusammenfassen.

• Das einfache Lesen der Partitur des frühen Modells macht es nicht zu einer spielbaren KI
• KI, die nur die Gewinnnote von Schwarzweiß liest, macht eher einen Fehler.
• Die KI von MLP sollte mit einer Funktion ausgestattet sein, die zumindest die Hand modifizieren kann, die das Spiel als ausfallsicher fortsetzen kann, wenn die falsche Hand ausgewählt wird.
• Wenn Sie in AIP in AI Fail Safe festlegen, eine große Anzahl von Notenzeilen mit MLP vs Random erwerben und erneut mit diesen Notenzeilen trainieren, können Sie die Wahrscheinlichkeit eines Fehlers verringern.

Ist es so ein Ort? Gegenwärtig wurde die Wahrscheinlichkeit, einen illegalen Zug auszuwählen, auf 8,0% reduziert, sodass KI mit Fail Safe das Ergebnis in der Mitte sein wird. Nun, dies mag das Endergebnis sein, aber ich bin ein wenig enttäuscht. Ab nächster Woche werde ich mit den Einstellungen des MLP-Modells spielen. Ich werde diesem Artikel mehr über zukünftige Versuche hinzufügen. Wenn Sie an der Entwicklung interessiert sind, schauen Sie sie sich bitte an.

In dieser Studie ist es in meiner Umgebung ein großer Engpass, dass es jedes Mal mehrere Stunden dauert, um das Modell anhand der Partitur zu trainieren ... Wenn Sie eine GPU verwenden können, können Sie dies meiner Meinung nach etwas einfacher tun. Daher wäre es interessant, "* build_mlp.py *" neu zu schreiben, um die GPU zu unterstützen und verschiedene Dinge auszuprobieren.

** ↓↓↓↓↓ 14.08.2016 Update ↓↓↓↓↓ **

Bestätigung der Lernkurve

"* Bulb_mlp.py *" wurde aktualisiert, um die Lernkurve anzuzeigen. Reservieren Sie 1000 Proben am Ende der Daten als Testdaten (Validierung) (diese 1000 Proben werden nicht für das Training verwendet) und für die korrekte Antwortrate (Haupt- / Genauigkeit) in den Trainingsdaten in jeder Epoche und die dem Modell unbekannten Testdaten Die richtige Antwortrate (Validierung / Haupt / Genauigkeit) wird angezeigt. Jetzt können Sie die Lernkurve zeichnen. Nun, es ist eine Geschichte, die du endlich von Anfang an machen solltest ...

Zunächst wird die Trainingskurve im frühen Modell gezeigt.

Bei 1000 Epoche ist die Haupt- / Genauigkeit bei etwa 0,45 gesättigt. Es kann beurteilt werden, dass der Versuch, die in Versuch 2 durchgeführte Epoche von 1000 auf 3000 zu ändern, unwirksam erscheint. Ist die richtige Antwortrate von 0,45 = 45% übrigens nicht niedrig? Sie mögen denken, aber da wir die tatsächliche Punktzahl verwenden, gibt es mehrere Schritte, um eine bestimmte Board-Bedingung zu beantworten. Es scheint also, dass die richtige Antwortrate nicht so hoch ist.

Als nächstes wird die Lernkurve gezeigt, wenn die Anzahl der Neuronen in der verborgenen Schicht (h1, h2) von 100 auf 200 erhöht wird.

Es ist dasselbe, dass es bei ungefähr 1000 Epochen fast konvergiert. Das Erhöhen der Anzahl von Neuronen erhöht die korrekte Antwortrate (Haupt / Genauigkeit) der Trainingsdaten, aber der Wert von Validierung / Haupt / Genauigkeit, der die richtige Antwortrate für unbekannte Eingaben ist, ist fast der gleiche wie bei einer Anzahl von Neuronen von 100. Das heißt ... Ich glaube nicht, dass ich die Regeln einhalten kann, selbst wenn ich von 100 auf 200 Neuronen wechsle ... Aber vorerst werde ich es als Wiederholungsversuch 5 überprüfen.

Wiederholen Sie Versuch 5: Erhöhen Sie die h1- und h2-Neuronen von 100 auf 200

Ich dachte, dass eine Erhöhung der Anzahl der Neuronen den Trainingseffekt auf die Punktzahl erhöhen und es ermöglichen würde, die Regeln einzuhalten. Ändern Sie die Definition der MLP-Klasse in "* build_mlp.py *".

...
class MLP(Chain):
    def __init__(self):
        super(MLP, self).__init__(
                l1=L.Linear(64,200)
                l2=L.Linear(200,200)
                l3=L.Linear(200,65)
        )
...

Erstellen Sie nach den Änderungen ein trainiertes Modell.

$ python build_mlp.py Othelo.01e4.ggf black 100 1000
$ mv reversi_model.npz model_neuron-200_black.npz
$ python build_mlp.py Othelo.01e4.ggf white 100 1000
$ mv reversi_model.npz model_neuron-200_white.npz

Rematch mit MLP vs Random unter Verwendung des neuen Modells (* model_neuron-200_black.npz, model_neuron-200_white.npz ). (Die Definition der MLP-Klasse in " reversi.py *" muss ebenfalls wie oben beschrieben geändert werden.) Illegale Bewegung! 10778 Mal in 1000 Schlachten aufgetreten. Die Aufteilung ist wie folgt.

Da es 10997/30000 ist, führen wir betrügerische Handlungen mit einer Rate von 36,7% durch. Es wird schlimmer ... vielleicht passt es zu sehr zu den Trainingsdaten.

Wiederholen Sie 6: Erhöhen Sie die Trainingsprobe um etwa das Dreifache

Verbinden Sie nicht nur Othello.01e4.ggf, sondern auch Othello.02e4.ggf und Othello.03e4.ggf, um die Schachpartitur zu lesen, und versuchen Sie, mehr verschiedene Muster zu lernen, indem Sie den Betrag um etwa das Dreifache erhöhen.

$ cat Othello.01e4.ggf Othello.02e4.ggf Othello.03e4.ggf > Othello.01-03e4.ggf
$ python build_mlp.py Ohtello.01-03e4.ggf black 100 1000
$ mv reversi_model.npz model_01-03e4_black.npz 
$ python build_mlp.py Ohtello.01-03e4.ggf white 100 1000
$ mv reversi_model.npz model_01-03e4_white.npz

Die Lernkurve ist wie folgt. Die Validierung / Haupt / Genauigkeit hat sich von 0,3 auf 0,35 verbessert, verglichen mit dem Fall, in dem die Punktzahl nur Othello.01e4.ggf ist. Kannst du ein wenig erwarten?

Rematch mit MLP vs Random unter Verwendung des neuen Modells (* model_01-03e4_black.npz, model_01-03e4_white.npz *). Illegaler Zug! 5284 Mal in 1000 Spielen aufgetreten. Die Aufteilung ist wie folgt.

Da es sich um 5284/30000 handelt, ist es mit einer Rate von 17,6% illegal. Es unterscheidet sich nicht wesentlich von dem Fall, in dem nur Othello.01e4.ggf für die Spielpunktzahl verwendet wird (19,1%). Es wird ziemlich chaotisch ...

Wiederholen Sie 7: Fügen Sie dem MLP-Eingang "Platz" -Informationen hinzu (Kartenbedingung)

Dieses Mal werde ich meine Meinung ändern und versuchen, den MLP-Eingang selbst zu ändern. Insbesondere zusätzlich zu '0': Keine, '1': Schwarz, '2': Weiß und '3': Ort, an dem die Karteninformationen als Eingabe eingegeben werden sollen. Zum Beispiel. X1 ist der Zustand X0 im Fall der schwarzen Kurve, wobei ein Platz zum Hinzufügen hinzugefügt wird.

X0 = [[0,0,0,0,0,0,0,0],\
      [0,0,0,0,0,0,0,0],\
      [0,0,0,0,0,0,0,0],\
      [0,0,0,2,1,0,0,0],\
      [0,0,1,2,2,2,2,0],\
      [0,0,0,1,2,2,0,0],\
      [0,0,0,0,1,2,0,0],\
      [0,0,0,0,0,0,0,0]]

X1 = [[0,0,0,0,0,0,0,0],\
      [0,0,0,0,0,0,0,0],\
      [0,0,0,3,3,0,0,0],\
      [0,0,3,2,1,3,0,3],\
      [0,0,1,2,2,2,2,3],\
      [0,0,3,1,2,2,3,0],\
      [0,0,0,0,1,2,3,0],\
      [0,0,0,0,0,0,0,0]]

Auf diese Weise dachte ich, dass eine KI erstellt werden könnte, die den Regeln entspricht. Es scheint einen Tsukkomi zu geben, der sagt: "Ich erzähle Ihnen fast die Regeln!", Aber die Prämisse, dass der Status des Boards als Eingabe verwendet wird und der nächste Schritt erhalten wird, da sich die Ausgabe nicht geändert hat. (Eine ziemlich schmerzhafte Ausrede ...) "* Build_mlp.py *" wurde geändert, um anzugeben, ob ein Platz zum Platzieren hinzugefügt werden soll. Wenn True am Ende des Befehls hinzugefügt wird, wird die Stelle, an der es platziert werden kann, als '3' zur Eingabeplatine hinzugefügt.

$ pythohn build_mlp.py Othello.01e4.ggf black 100 1000 True
$ mv reversi_model.npz model_black_puttable_mark.npz 
$ pythohn build_mlp.py Othello.01e4.ggf white 100 1000 True
$ mv reversi_model.npz model_white_puttable_mark.npz 

Die Lernkurve ist wie folgt.

Es hat die bisher höchste Validierung / Haupt- / Genauigkeit und konvergiert bei etwa 0,4.

Rematch mit MLP vs Random unter Verwendung des neuen Modells (* model_black_puttable_mark.npz, model_white_puttable_mark.npz ). " Reversi.py " wurde behoben, um diese Modelle zu unterstützen. Wenn der angegebene MLP-Modellname " puttable_mark *" enthält, entspricht er der Eingabe, die durch "3" dargestellt wird, wo er platziert werden kann.

Illegaler Zug! 207 Mal in 1000 Schlachten aufgetreten. Die Aufteilung ist wie folgt.

Da es 207/30000 ist, machen wir mit einer Rate von 0,7% etwas Illegales. Was für 1% oder weniger! Es ist eine dramatische Verbesserung.

Abschließende Zusammenfassung

Ich werde das Obige zusammenfassen.

• Das einfache Lesen der Partitur des frühen Modells macht es nicht zu einer spielbaren KI
• KI, die nur die Gewinnnote von Schwarzweiß liest, macht eher einen Fehler.
• Die KI von MLP sollte mit einer Funktion ausgestattet sein, die zumindest die Hand modifizieren kann, die das Spiel als ausfallsicher fortsetzen kann, wenn die falsche Hand ausgewählt wird.
• Wenn Sie in AIP in AI Fail Safe festlegen, eine große Anzahl von Notenzeilen mit MLP vs Random erwerben und erneut mit diesen Notenzeilen trainieren, können Sie die Wahrscheinlichkeit eines Fehlers verringern.
• Eine Erhöhung der Anzahl der MLP-Neuronen kann die Wahrscheinlichkeit eines Fehlers nicht verringern (eher verschlechtern)
• Das Erhöhen der MLP-Trainingsmuster verringert nicht die Wahrscheinlichkeit, einen Fehler zu machen
• Das Hinzufügen von "Platz zum Platzieren" als Information zum Status des Boards, bei dem es sich um die Eingabe handelt, kann die Möglichkeit eines Fehlers erheblich verbessern.

Ist es als KI, die richtig funktioniert, die mit "Fail Safe", die mit "Place" als "3" im Status des Boards hinzugefügt wurde? Es mag ein bisschen schlampig sein, aber ich konnte eine anständige KI machen.

Gegenwärtig hängt die Stärke der KI nur von der Punktzahl ab. Nachdem die grundlegende KI mit der oben beschriebenen Methode erstellt wurde, wird sie durch die Stärkung des Lernens usw. gestärkt. Ich bin völlig unwissend über das Lernen von Verstärkung, also werde ich es nach dem Studium versuchen.

Danke für deine Rücksicht. Es war arm.