[PYTHON] Brechen Sie Blöcke mit Tensorflow

Überblick

Das Einbeziehen eines Modells für maschinelles Lernen in das Spiel macht Spaß, da Sie die Ergebnisse grafisch anzeigen können. Erstellen Sie daher mit Tensorflow ein Modell und integrieren Sie es in das Spiel. Insbesondere erstellt Tensorflow ein Modell, bei dem Spieldaten von Menschenhand verwendet werden, um Blöcke zu brechen. Mach dir keine Sorgen über anspruchsvolle Modelle, mach ** ordentliche ** Dinge ** ordentlich **. Die grundlegende Modellerstellung mit Tensorflow finden Sie im folgenden Artikel Tensorflow richtig verstehen und ein Modell erstellen (Einführung in Tensorflow) Der verwendete Blockschalter ist der unten verlinkte Blockbruch

Motivation

Ich sehe oft Artikel, in denen Modelle für maschinelles Lernen auf verschiedene Arten gespielt werden können, aber ich würde es gerne ausprobieren, ohne Zeit zu investieren. Der Zweck ist es, es so zu bewegen, dass Sie fühlen können, wie es sich bewegt, ohne sich um seine Genauigkeit und Schönheit sorgen zu müssen.

Annahme

Der Umriss des diesmal verwendeten Blockbruchs ist wie folgt.

Bewegen Sie das Paddel und spielen Sie den Ball
Bestimmen Sie die Paddelkoordinaten mit der x-Koordinate der Maus

Mit anderen Worten, wenn die y-Koordinate des Balls und die y-Koordinate des Paddels übereinstimmen, ist es möglich, den Ball so lange zu spielen, wie die x-Koordinaten jedes Spiels. In diesem Sinne ist das Erstellen eines automatischen Blockschalters ziemlich schonend.

Datenerstellung

Erstellen Sie Daten aus dem tatsächlichen Spiel. Dieses Mal ist der Zweck, mit ** Kito ** fortzufahren, daher werde ich den Satz erklärender Variablen und erklärter Variablen nicht im Detail betrachten. Schreiben Sie beim tatsächlichen Spielen zunächst die Paddelkoordinaten und Ballkoordinaten gemäß dem Zeitpunkt der Bildschirmaktualisierung aus. Die x- und y-Koordinaten des Balls, die in jedem Frame platziert werden können, sind die erklärenden Variablen, und die Position des Paddels ist die erklärte Variable. Erstellen Sie die zu verwendenden Daten. Schreiben Sie dazu den Prozess des Schreibens (Speicherns) jeder Koordinate in die Bewegungsfunktion der Ball-Klasse und die Aktualisierungsfunktion der Paddle-Klasse.

Modell erstellen

`model.py`


#Bibliotheksimport
import tensorflow as tf
import pandas as pd

#Daten gelesen
data_x = pd.read_csv('/somewhere/ball_movement_x.csv', header=None)
data_y = pd.read_csv('/somewhere/ball_movement_y.csv', header=None)
movement = pd.read_csv('/somewhere/mouse_movement.csv', header=None)

data = pd.DataFrame({'x_data': data_x.ix[:, 0],
                     'y_data': data_y.ix[:, 0]
                     })
teacher = pd.DataFrame({'teacher':movement.ix[:, 0]})

#Modellieren
#Platzhaltereinstellungen
X = tf.placeholder(tf.float32, shape = [None, 2])
Y = tf.placeholder(tf.float32, shape = [None, 1])

#Variable Einstellung
W = tf.Variable(tf.zeros([2,1]))

B = tf.Variable(tf.zeros([1]))

y_hypo = tf.matmul(X, W) + B

#Verlustfunktion
cost = tf.reduce_mean(tf.square(y_hypo - Y))

#Gradientenabstieg
train_step = tf.train.GradientDescentOptimizer(0.000001).minimize(cost)


with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(1000):
        sess.run(train_step, feed_dict={X:data, Y:teacher})
    parameter_W = sess.run(W)
    parameter_B = sess.run(B)

Schau in der richtigen Reihenfolge

`model.py`


#Modellieren
#Platzhaltereinstellungen
X = tf.placeholder(tf.float32, shape = [None, 2])
Y = tf.placeholder(tf.float32, shape = [None, 1])

#Variable Einstellung
W = tf.Variable(tf.zeros([2,1]))
B = tf.Variable(tf.zeros([1]))

y_hypo = tf.matmul(X, W) + B

In der Lernphase werden den Platzhaltern tatsächliche Daten zugewiesen und während des Trainings Variablen als Parameter festgelegt. y_hypo ist ein Modell zur Vorhersage von Paddelkoordinaten basierend auf Daten und Parametern.

`optimize.py`


#Verlustfunktion
cost = tf.reduce_mean(tf.square(y_hypo - Y))

#Gradientenabstieg
train_step = tf.train.GradientDescentOptimizer(0.000001).minimize(cost)


with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(1000):
        sess.run(train_step, feed_dict={X:data, Y:teacher})
    parameter_W = sess.run(W)
    parameter_B = sess.run(B)

Eigentlich lernen und nach Parametern suchen. parameter_W und parameter_B sind die erhaltenen Parameter, X sind die Eingabedaten (x- und y-Koordinaten des Balls) und der Wert von tf.matmul (X, parameter_W) + parameter_B ist die vorhergesagte Koordinate des Paddels.

Lauf

Holen Sie sich die Koordinaten des Balls während der Hauptfunktion, fügen Sie ihn in das obige Modell ein und verwenden Sie den vorhergesagten Wert als Koordinaten des Paddels. Es ist sehr schwer, da die Vorhersage jedes Mal gemacht wird, wenn die Informationen aktualisiert werden, aber vorerst funktioniert es wie folgt.

ezgif.com-resize.gif

Impressionen

Der Zweck dieser Zeit war es, das Modell in das Spiel zu integrieren und es zum Laufen zu bringen, aber es funktionierte. In der Realität werden wir fortfahren und darauf achten, welche Art von Daten verwendet werden und wie die Bewegung komplexer gestaltet werden kann. Zum Beispiel wurde im Fall des Blockbruchs dieses Mal, wenn die Blöcke bis zu einem bestimmten Punkt verschwanden, die Bewegung des Paddels und des Balls fixiert und es kam vor, die ganze Zeit ohne Blöcke im Raum hin und her zu gehen. Außerdem war es ineffizient, jedes Mal Vorhersagen zu treffen, wenn der Rahmen aktualisiert wurde, und die Bewegung des Balls war sehr langsam.