J'ai essayé de créer un environnement pour renforcer l'apprentissage d'Othello avec OpenAI gym. J'espère que cela sera utile pour ceux qui souhaitent créer un environnement propice à un apprentissage amélioré à l'avenir. L'algorithme d'apprentissage n'est pas implémenté. Je vais étudier à partir de maintenant. Cliquez-ici pour le code https://github.com/pigooosuke/gym_reversi
Par défaut, gym / envs contient divers environnements d'apprentissage. Au fait, dans le système de jeu de société, il y a Go et hex. Cette fois, je l'ai créé en référence à ces codes.
L'env créé peut être appelé comme suit.
import gym
env = gym.make('Reversi8x8-v0')
Classe créée ReversiEnv En gros, il est nécessaire d'écrire du code centré sur 5 méthodes en Env. _step Avancez le nombre de pas de un (Sortez la main du joueur et la main de l'adversaire et vérifiez si le jeu est terminé)
_reset Chargez les paramètres par défaut d'Env (Chargement du plateau, première et deuxième attaque, etc.)
_render Illustrez l'état d'Env (l'image, RVB, le texte sont définis) (Affiche l'état des pierres sur le plateau)
_close Supprimer toutes les informations Env (Inutilisé cette fois)
_seed Utilisé pour déterminer l'action par graine aléatoire (Réglage)
La valeur initiale est player_color: Couleur de la pierre du joueur (noir en premier) adversaire: stratégie de l'adversaire (aléatoire cette fois) observation_type: encodage de l'état (paramètres inutiles? Vous pouvez peut-être le supprimer. Déclaration indiquant que l'état est géré par numpy3c. Je l'ai laissé pour le moment) legal_place_mode: Pénalités pour erreur de jeu (perte, etc.) board_size: taille de la carte (8 cette fois)
Est réglé.
action action décide de l'action à entreprendre contre Env. Puisqu'il s'agit d'une planche 8x8, 0-63 est la position de l'attaquant, 64 est la fin et 65 est la passe. C'est une image pour introduire la sortie de l'apprentissage par renforcement dans la partie action
done Plus tard dans le processus d'étape, vous devez vérifier si le jeu est terminé à la suite de cette étape.
reward La méthode d'évaluation est définie pour gagner ou perdre 1, -1.
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
Au début, je n'ai défini aucune règle du tout, je l'ai réglé pour qu'il prenne 0-63 en action dans n'importe quel statut (je peux mettre des pierres n'importe où) et j'ai essayé d'apprendre les règles elles-mêmes, mais cela a convergé en apprenant les premier et deuxième coups Je n'ai pas bien appris car j'ai fini par limiter la valeur de l'action.
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