[Comment!] Apprenez et jouez à Super Mario avec Tensorflow !!

introduction

La dernière fois, il y a eu de nombreuses demandes d'apprentissage du logiciel Super Famicom, donc cette fois je partagerai un programme d'apprentissage de Famicom qui fonctionne sur Macbook, etc.

Je l'ai téléchargé sur Git afin qu'il puisse fonctionner dans l'expérience. S'il vous plaît Star si vous souhaitez télécharger! https://github.com/tsunaki00/super_mario

Environnement d'expérimentation

Je l'ai testé dans l'environnement machine suivant.

environnement
PC	Macbook PRO 2016 OSX
CPU	i7
MEM	16GB
langage de développement	python

Il a également fonctionné sur Macbook 12

Supplément

L'apprentissage avec Tensorflow se fait de manière appropriée, veuillez donc l'améliorer.

Précautions concernant l'environnement

Lorsque je l'exécute, j'obtiens l'erreur suivante et je dois réparer la bibliothèque.

$ python3 start.py 
  Traceback (most recent call last):
    File "start.py", line 22, in <module>
      import gym_pull
    File "/usr/local/lib/python3.6/site-packages/gym_pull/__init__.py", line 41, in <module>
      import gym_pull.monitoring.monitor
    File "/usr/local/lib/python3.6/site-packages/gym_pull/monitoring/monitor.py", line 10, in <module>
      class Monitor(gym.monitoring.monitor.Monitor):
  AttributeError: module 'gym.monitoring' has no attribute 'monitor'

↓ Corrigé ci-dessous

$ vi /usr/local/lib/python3.6/site-packages/gym_pull/monitoring/monitor.py
   :
   :
  class Monitor(gym.monitoring.monitor.Monitor):
   ↓
  class Monitor(gym.monitoring.monitor_manager.MonitorManager):

Une brève description du programme

La méthode d'apprentissage est l'apprentissage par renforcement. Vous apprendrez à évaluer les actions que vous avez effectuées, ce qui est un peu différent de l'apprentissage supervisé et non supervisé.

[Référence] Deep Q-Network

Il y avait une description de DQN dans l'article ci-dessous. Histoire de DQN + Deep Q-Network écrite dans Chainer

[Référence] Apprenez les opérations humaines.

Nous avons pu créer le Mario le plus rapide comme indiqué ci-dessous en laissant l'évaluation apprendre les résultats de notre propre exécution! Les évaluations sont la distance, le temps et le score.

[[Intelligence Artificielle] J'ai essayé de laisser l'intelligence artificielle SIVA jouer à Mario![MONDE 1-1]] https://www.youtube.com/watch?v=T4dO1GKPx4Y

Code source

――L'action doit être réduite correctement.

Comme il est agencé de manière à pouvoir être utilisé pour le traitement par mini-lots, veuillez le modifier le cas échéant. ―― Ce sera encore mieux si vous ajoutez occasionnellement du hasard!

import tensorflow as tf
import gym
import gym_pull
import ppaquette_gym_super_mario
from gym.wrappers import Monitor
import random
import numpy as np
class Game :

  def __init__(self):
    self.episode_count = 10000;
    ## select stage
    self.env = gym.make('ppaquette/SuperMarioBros-1-1-Tiles-v0')

  def weight_variable(self, shape):
    initial = tf.truncated_normal(shape, stddev = 0.01)
    return tf.Variable(initial)

  
  def bias_variable(self, shape):
    initial = tf.constant(0.01, shape = shape)
    return tf.Variable(initial)

  def conv2d(self, x, W, stride):
    return tf.nn.conv2d(x, W, strides = [1, stride, stride, 1], padding = "SAME")

  def max_pool_2x2(self, x):
    return tf.nn.max_pool(x, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = "SAME")

  
  def create_network(self, action_size):
    #Faites-en deux couches
    W_conv1 = self.weight_variable([8, 8, 1, 16])
    b_conv1 = self.bias_variable([16])
    W_conv2 = self.weight_variable([4, 4, 16, 32])
    b_conv2 = self.bias_variable([32])
    W_conv3 = self.weight_variable([4, 4, 32, 64])
    b_conv3 = self.bias_variable([64])
    W_fc1 = self.weight_variable([512, action_size])
    b_fc1 = self.bias_variable([action_size])
    s = tf.placeholder("float", [None, 13, 16, 1])
    # hidden layers
    h_conv1 = tf.nn.relu(self.conv2d(s, W_conv1, 2) + b_conv1)
    h_conv2 = tf.nn.relu(self.conv2d(h_conv1, W_conv2, 2) + b_conv2)
    h_conv3 = tf.nn.relu(self.conv2d(h_conv2, W_conv3, 1) + b_conv3)
    h_conv3_flat = tf.reshape(h_conv3, [-1, 512])
    readout = tf.matmul(h_conv3_flat, W_fc1) + b_fc1
    return s, readout 


  def play_game(self) :
    action_list = []
    for i in range(64) :
      command = format(i, 'b')
      command = '{0:06d}'.format(int(command))
      actions = []
      for cmd in list(command) :
        actions.append(int(cmd))
      action_list.append(actions)
    sess = tf.InteractiveSession()
    s, readout = self.create_network(len(action_list))
    a = tf.placeholder("float", [None, len(action_list)])
    y = tf.placeholder("float", [None, 1])
    readout_action = tf.reduce_sum(tf.multiply(readout, a), reduction_indices = 1)
    cost = tf.reduce_mean(tf.square(y - readout_action))
    train_step = tf.train.AdamOptimizer(1e-6).minimize(cost)
    saver = tf.train.Saver()
    sess.run(tf.initialize_all_variables())
    checkpoint = tf.train.get_checkpoint_state("./saved_networks/checkpoints")
    if checkpoint and checkpoint.model_checkpoint_path:
      saver.restore(sess, checkpoint.model_checkpoint_path)
      print ("Successfully loaded:", checkpoint.model_checkpoint_path)
    else:
      print ("Could not find old network weights")
    for episode in range(self.episode_count):
      self.env.reset()
      total_score = 0
      distance = 0
      is_finished = False
      actions, rewards, images = [], [] ,[]
      while is_finished == False :
        #Obtenez le point en haut à gauche de l'écran(Si vous le faites avec une image, vous.env.Vous pouvez l'obtenir sur l'écran)
        screen = np.reshape(self.env.tiles, (13, 16, 1))
        if episode < 10 :
          action_index = random.randint(0, len(action_list) - 1)
        else :
          readout_t = readout.eval(feed_dict = {s : [screen]})[0]
          action_index = np.argmax(readout_t)
        # (1)Traitement vers Mario à l'écran(self.env.step)
        obs, reward, is_finished, info = self.env.step(action_list[action_index])
        ##Dans un tableau pour en faire un mini lot
        action_array = np.zeros(len(action_list))
        action_array[action_index] = 1
        actions.append(action_array)
        # (2)Offrez une récompense
        rewards.append([float(info['distance'])])
        images.append(screen)

        train_step.run(feed_dict = {
          a : actions, y : rewards, s : images
        })
        print('Episode : ', episode, 'Actions : ', action_list[action_index], 'Rewards', reward)
        actions, rewards, images = [], [] ,[]
        
        self.env.render()
      saver.save(sess, 'saved_networks/model-dqn', global_step = episode)

if __name__ == '__main__' :
  game = Game()
  game.play_game()

Courir


$ python3 start.py

finalement

La version du navigateur Docker + sera écrite séparément.

Récemment, de nombreux ouvrages techniques tels que l'IA ont été publiés, mais je pense que les obstacles sont assez élevés ... Je pense que c'est une bonne idée de s'entraîner avec quelque chose de familier comme ça!

Une session d'étude distincte sera organisée pour plus de détails sur les programmes pour Game AI et Python. Rejoignez-nous si vous le souhaitez,

Tech Twitter a commencé. Nous le mettrons à jour de temps en temps, alors suivez-nous si vous le souhaitez. https://twitter.com/gauss_club