Ich habe versucht, mit OpenAI Gym ein Umfeld zu schaffen, um das Lernen von Othello zu stärken. Ich hoffe, es wird hilfreich für diejenigen sein, die in Zukunft ein Umfeld für verbessertes Lernen schaffen möchten. Der Lernalgorithmus ist nicht implementiert. Ich werde von nun an lernen. Klicken Sie hier für den Code https://github.com/pigooosuke/gym_reversi
Standardmäßig enthält gym / envs verschiedene Lernumgebungen. Übrigens gibt es im Brettspielsystem Go und Hex. Dieses Mal habe ich es mit Bezug auf diese Codes erstellt.
Das erstellte Env kann wie folgt aufgerufen werden.
import gym
env = gym.make('Reversi8x8-v0')
Erstellt Klasse ReversiEnv Grundsätzlich ist es notwendig, Code zu schreiben, der sich auf 5 Methoden in Env konzentriert. _step Erhöhen Sie die Anzahl der Schritte um eins (Geben Sie die Hand des Spielers und des Gegners aus und prüfen Sie, ob das Spiel beendet ist.)
_reset Laden Sie die Standardeinstellungen von Env (Laden des Bretts, erster und zweiter Angriff usw.)
_render Veranschaulichen Sie den Status von Env (Bild, RGB, Text sind festgelegt) (Zeigt den Status der Steine auf dem Brett an.)
_close Verwerfen Sie alle Env-Informationen (Diesmal nicht verwendet)
_seed Wird verwendet, um die Aktion durch zufälligen Startwert zu bestimmen (Aufbau)
Der Anfangswert ist player_color: Spielersteinfarbe (zuerst schwarz) Gegner: Strategie des Gegners (diesmal zufällig) Beobachtungstyp: Statuskodierung (unnötige Einstellungen? Vielleicht können Sie sie löschen. Erklärung, dass der Status von numpy3c verwaltet wird. Ich habe ihn vorerst verlassen) illegal_place_mode: Strafen für Fehlspiele (Verlieren usw.) board_size: Boardgröße (diesmal 8)
Ist eingestellt.
action Aktion entscheidet, welche Aktion gegen Env. Da es sich um ein 8x8-Brett handelt, ist 0-63 die Position des Stürmers, 64 das Ende und 65 der Pass. Es ist ein Bild, um die Ergebnisse des Verstärkungslernens im Aktionsteil einzuführen
done Später im Schritt müssen Sie überprüfen, ob das Spiel als Ergebnis dieses Schritts beendet ist.
reward Die Bewertungsmethode ist so eingestellt, dass sie 1, -1 gewinnt oder verliert.
def game_finished(board):
# Returns 1 if player 1 wins, -1 if player 2 wins and 0 otherwise
d = board.shape[-1]
player_score_x, player_score_y = np.where(board[0, :, :] == 1)
player_score = len(player_score_x)
opponent_score_x, opponent_score_y = np.where(board[1, :, :] == 1)
opponent_score = len(opponent_score_x)
if player_score == 0:
return -1
elif opponent_score == 0:
return 1
else:
free_x, free_y = np.where(board[2, :, :] == 1)
if free_x.size == 0:
if player_score > (d**2)/2:
return 1
elif player_score == (d**2)/2:
return 1
else:
return -1
else:
return 0
return 0
Zuerst habe ich überhaupt keine Regeln festgelegt, ich habe 0-63 in jedem Status in Aktion gesetzt (ich kann überall Steine setzen) und versucht, die Regeln selbst zu lernen, aber es konvergierte, indem ich den ersten und zweiten Zug lernte Ich konnte nicht gut lernen, weil ich den Wert des Handelns einschränkte.
python
def get_enable_to_actions(board, player_color):
actions=[]
d = board.shape[-1]
opponent_color = 1 - player_color
for pos_x in range(d):
for pos_y in range(d):
if (board[2, pos_x, pos_y]==0):
continue
for dx in [-1, 0, 1]:
for dy in [-1, 0, 1]:
if(dx == 0 and dy == 0):
continue
nx = pos_x + dx
ny = pos_y + dy
n = 0
if (nx not in range(d) or ny not in range(d)):
continue
while(board[opponent_color, nx, ny] == 1):
tmp_nx = nx + dx
tmp_ny = ny + dy
if (tmp_nx not in range(d) or tmp_ny not in range(d)):
break
n += 1
nx += dx
ny += dy
if(n > 0 and board[player_color, nx, ny] == 1):
actions.append(pos_x*8+pos_y)
if len(actions)==0:
actions = [d**2 + 1]
return actions
Recommended Posts