[PYTHON] [How to!] Lerne und spiele Super Mario mit Tensorflow !!

Einführung

Letztes Mal gab es viele Anfragen zum Erlernen der Super Famicom-Software, daher werde ich dieses Mal ein Programm zum Erlernen von Famicom teilen, das auf Macbook usw. ausgeführt wird.

Ich habe es auf Git hochgeladen, damit es im Experiment funktioniert. Bitte Stern, wenn Sie herunterladen möchten! https://github.com/tsunaki00/super_mario

Experimentierumgebung

Ich habe es in der folgenden Maschinenumgebung getestet.

Umgebung
PC	Macbook PRO 2016 OSX
CPU	i7
MEM	16GB
Entwicklungssprache	python

Es funktionierte auch auf Macbook 12

Ergänzung

Das Lernen mit Tensorflow wird entsprechend durchgeführt. Bitte verbessern Sie es.

Vorsichtsmaßnahmen für die Umwelt

Wenn ich es ausführe, erhalte ich den folgenden Fehler und muss die Bibliothek reparieren.

$ 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'

↓ Unten korrigiert

$ 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):

Eine kurze Beschreibung des Programms

Die Lernmethode ist Reinforcement Learning. Sie lernen, die von Ihnen durchgeführten Aktionen zu bewerten, was sich ein wenig vom überwachten und unbeaufsichtigten Lernen unterscheidet.

[Referenz] Deep Q-Network

Im folgenden Artikel wurde DQN beschrieben. Geschichte von DQN + Deep Q-Network in Chainer geschrieben

[Referenz] Lernen Sie menschliche Operationen.

Wir konnten den schnellsten Mario wie folgt machen, indem wir die Bewertung die Ergebnisse unserer eigenen Ausführung erfahren ließen! Bewertungen sind Entfernung, Zeit und Punktzahl.

Künstliche Intelligenz Ich habe versucht, die künstliche Intelligenz SIVA Mario spielen zu lassen![WELT 1-1]] https://www.youtube.com/watch?v=T4dO1GKPx4Y

Quellcode

――Aktion sollte richtig eingegrenzt werden.

Da es so angeordnet ist, dass es für die Mini-Batch-Verarbeitung verwendet werden kann, ändern Sie es bitte entsprechend. ――Es wird noch besser, wenn Sie gelegentlich zufällig hinzufügen!

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):
    #Machen Sie es zwei Schichten
    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 :
        #Holen Sie sich den Punkt oben links auf dem Bildschirm(Wenn du es mit einem Bild machst, selbst.env.Sie können es auf dem Bildschirm erhalten)
        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)Verarbeitung zu Mario auf dem Bildschirm(self.env.step)
        obs, reward, is_finished, info = self.env.step(action_list[action_index])
        ##In einem Array, um es zu einem Mini-Batch zu machen
        action_array = np.zeros(len(action_list))
        action_array[action_index] = 1
        actions.append(action_array)
        # (2)Gib eine Belohnung
        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()

Lauf


$ python3 start.py

Schließlich

Die Docker + Browser-Version wird separat geschrieben.

In letzter Zeit wurden viele technische Bücher wie AI veröffentlicht, aber ich denke, dass die Hürden ziemlich hoch sind ... Ich denke, es ist eine gute Idee, mit so etwas Vertrautem zu üben!

In einer separaten Lernsitzung werden Einzelheiten zu den Programmen für Game AI und Python erläutert. Bitte schließen Sie sich uns an, wenn Sie möchten,

Tech Twitter hat begonnen. Wir werden es von Zeit zu Zeit aktualisieren. Bitte folgen Sie uns, wenn Sie möchten. https://twitter.com/gauss_club