[PYTHON] Casser des blocs avec Tensorflow

Aperçu

Incorporer un modèle d'apprentissage automatique dans le jeu est amusant car vous pouvez voir les résultats graphiquement. Par conséquent, créez un modèle avec Tensorflow et intégrez-le dans le jeu. Plus précisément, Tensorflow crée un modèle en utilisant des données de lecture par des mains humaines pour casser des blocs. Ne vous inquiétez pas des modèles sophistiqués, faites des choses ** soignées ** ** soignées **. La création de modèle de base avec Tensorflow se trouve dans l'article suivant Comprendre correctement Tensorflow et créer un modèle (Introduction à Tensorflow) Le disjoncteur utilisé est celui lié ci-dessous Block Break

Motivation

Je vois souvent des articles qui permettent aux modèles d'apprentissage automatique de jouer de différentes manières, mais j'aimerais l'essayer sans perdre de temps. Le but est de le déplacer pour que vous puissiez le sentir bouger sans vous soucier de sa précision et de sa beauté.

supposition

Le contour de la rupture de bloc utilisé cette fois est le suivant.

• Déplacez la raquette et jouez au ballon
• Déterminez les coordonnées de la palette avec la coordonnée x de la souris

En d'autres termes, lorsque la coordonnée y de la balle et la coordonnée y de la palette correspondent, il est possible de jouer la balle aussi longtemps que les coordonnées x de chaque match. En ce sens, la création d'un disjoncteur de blocage automatique est assez douce.

Création de données

Créez des données à partir de la lecture réelle. Cette fois, le but est de passer à ** Kito **, je ne vais donc pas examiner l'ensemble des variables explicatives et des variables expliquées en détail. Tout d'abord, lorsque vous jouez réellement, écrivez les coordonnées de la palette et les coordonnées de la balle en fonction du moment de la mise à jour de l'écran, les coordonnées x et y de la balle qui peuvent être placées dans chaque image sont les variables explicatives et la position de la palette est la variable expliquée. Créez les données à utiliser. Pour ce faire, écrivez le processus d'écriture (sauvegarde) de chaque coordonnée dans la fonction de déplacement de la classe Ball et la fonction de mise à jour de la classe Paddle.

Créer un modèle

model.py

#Importation de bibliothèque
import tensorflow as tf
import pandas as pd

#Lecture des données
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]})

#La modélisation
#Paramètres d'espace réservé
X = tf.placeholder(tf.float32, shape = [None, 2])
Y = tf.placeholder(tf.float32, shape = [None, 1])

#Réglage variable
W = tf.Variable(tf.zeros([2,1]))

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

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

#Fonction de perte
cost = tf.reduce_mean(tf.square(y_hypo - Y))

#Descente graduelle
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)

Regardez dans l'ordre

model.py

#La modélisation
#Paramètres d'espace réservé
X = tf.placeholder(tf.float32, shape = [None, 2])
Y = tf.placeholder(tf.float32, shape = [None, 1])

#Réglage variable
W = tf.Variable(tf.zeros([2,1]))
B = tf.Variable(tf.zeros([1]))

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

Dans la phase d'apprentissage, les espaces réservés reçoivent des données réelles et les variables sont déterminées en tant que paramètres pendant la formation. y_hypo est un modèle de prédiction des coordonnées de pagaie basé sur des données et des paramètres.

optimize.py

#Fonction de perte
cost = tf.reduce_mean(tf.square(y_hypo - Y))

#Descente graduelle
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)

En fait, apprenez et recherchez des paramètres. parameter_W et parameter_B sont les paramètres obtenus, X est les données d'entrée (coordonnées x et y de la balle), et la valeur de tf.matmul (X, parameter_W) + parameter_B est la coordonnée prédite de la palette.

Courir

Obtenez les coordonnées de la balle dans le while de la fonction principale, placez-la dans le modèle ci-dessus et utilisez la valeur prédite comme coordonnées de la palette. C'est très lourd car la prédiction est faite à chaque fois que l'information est mise à jour, mais pour le moment, cela fonctionne comme suit.

Impressions

Le but de cette fois était d'incorporer le modèle dans le jeu et de le faire fonctionner, mais cela a fonctionné. En réalité, nous procéderons en prêtant attention au type de données qui sera utilisé et à la manière de rendre le mouvement plus sophistiqué. Par exemple, dans le cas du bloc cassant cette fois, lorsque les blocs ont disparu jusqu'à un certain point, le mouvement de la pagaie et de la balle était figé, et il en est venu à faire des allers-retours dans l'espace sans bloc tout le temps. De plus, il était inefficace de faire des prédictions chaque fois que l'image était mise à jour et le mouvement de la balle était très lent.