Outils pour utilisateurs

Outils du site


jeu_du_semaphore_dans_le_blender_game_engine

Ceci est une ancienne révision du document !


Jeu du sémaphore dans le Blender Game Engine

Une image pour l'apprentissage Une image à décrypter

Le projet sur Github

Etape 1

Création de 70 000 images

Dans un jeu Blender, 70 000 images sont créées, 60 0000 pour entraîner l'IA, 10 000 pour la tester. Ce jeu lit des textes en latin, sans caractères accentués ni spéciaux. Chaque lettre est affiché dans le jeu, puis une capture de la fenêtre est enregistrée. La fréquence est maxi de 12 fps. Il faut une heure et demi pour récupérer ces images.

Retaillage, flou et compression

Les images sont en noir et blanc, 320×320. Il faut les retailler en 40×40 et les flouter, puis les compresser.

Le Blender Game Engine 2.79 permet un affichage mini de 320×280. Les images du jeu sont donc en 320×320. Un script python3 avec opencv ori_to_40x40.py resize les images à 40×40 et les floutent.

IA

Ensuite faire l'apprentissage de et la tester.

Etape 2

En arrière plan, défile le documentaire NOTHING TO HIDE pour avoir un fond très varié:

Ressources sur les sémaphores et le télégraphe de Chappe

Un alphabet possible

Notre alphabet

  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • j
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • espace

Code qui marche de 80 à 88 %

import numpy as np, cv2
 
def sigmoid(x): return 1 / (1 + np.exp(-x))
def sigmoid_prime(z): return z * (1 - z)
def relu(x): return np.maximum(0, x)
def relu_prime(z): return np.asarray(z > 0, dtype=np.float32)
layers = [1600, 100, 100, 27]
activations, learningrate = [relu, relu, sigmoid], 0.05
 
f = np.load('/media/data/3D/projets/semaphore/semaphore.npz')
x_train, y_train = f['x_train'], f['y_train']
x_train = 1 - x_train
x_test, y_test = x_train[50000:,:], y_train[50000:]
x_train, y_train = x_train[:50000,:], y_train[:50000]
Y = np.eye(27, 27)
activations_prime = [globals()[f.__name__ + '_prime'] for f in activations]
A = {}
W = [np.random.randn(layers[k+1], layers[k]) / np.sqrt(layers[k]) for k in range(len(layers)-1)]
 
print("Training...")
cv2.namedWindow('img', cv2.WINDOW_NORMAL)
for epoch in range(1):
    for i, (a, d) in enumerate(zip(x_train, y_train)):
        if i % 100 == 0:
            print(epoch, i, d)
            cv2.imshow("img", a.reshape(40,40) * 255)
            cv2.waitKey(1)
        a = np.array(a, ndmin=2).T
        A[0] = a
        for k in range(len(layers)-1):
            z = np.dot(W[k], a)
            a = activations[k](z)
            A[k+1] = a
        delta_a = a - Y[:,[d]]
        for k in range(len(layers)-2, -1, -1):
            dz = delta_a * activations_prime[k](A[k+1])
            dW = np.dot(dz, A[k].T)
            delta_a = np.dot(W[k].T, dz)
            W[k] -= learningrate * dW
 
print("Testing...")
S = 0
for a, d in zip(x_test, y_test):
    for k in range(len(layers)-1):
        a = activations[k](np.dot(W[k], a))
    if np.argmax(a) == d:
        S += 1
print("Accuracy: %.1f %%" % (100.0 * S / len(x_test)))
np.save('weights', W)
jeu_du_semaphore_dans_le_blender_game_engine.1549267022.txt.gz · Dernière modification : 2019/02/04 07:57 de serge