** * Une addition ** Il y avait déjà un post avec un contenu similaire.
Bonsoir. C'est Rizento.
La plupart d'entre vous qui lisez cet article connaissent FizzBuzz. Si vous êtes un programmeur, vous pouvez avoir une sortie de 1 à 100 selon les règles de FizzBuzz. Cette fois, je vais essayer de faire que FizzBuzz "laisse AI le faire sans écrire de code". Le programme créé est publié sur GitHub.
Si vous savez ce que c'est, sautez-le.
Jetez un œil à Wikipedia.
Fizz Buzz (également connu sous le nom de Fizz Buzz, Bizz Buzz ou Buzz) est un jeu de mots qui se déroule lors de longues distances en voiture et de beuveries dans le monde anglophone.
En termes simples, lors de la liste des nombres dans l'ordre, ** Fizz ** au lieu des nombres lorsque les multiples de 3, ** Buzz ** lorsque les multiples de 5, ** FizzBuzz dans les deux cas. C'est un jeu appelé **. Ce sont les Nabeats du monde.
Le temps est 2020, et il est obsolète pour les humains de jouer à FizzBuzz plus. Préparons uniquement les règles du jeu par les humains et laissons la machine jouer le reste.
La méthode utilisée cette fois est l '** apprentissage amélioré **. C'est une technique souvent utilisée pour l'IA dans les jeux, et est également utilisée pour l'IA dans Go et Shogi.
Je n'écrirai pas sur l'apprentissage par renforcement ici. Si vous êtes intéressé, veuillez le vérifier par vous-même.
Lorsque les humains jouent à FizzBuzz, ils peuvent en fait donner une réponse s'ils ne connaissent que le numéro actuel, mais comme il n'a aucun goût d'IA, cette fois ** La réponse pour les 15 derniers tours ** est maintenant Donner à l'IA le ** statut ** de.
Tout d'abord, créez l'environnement de jeu de FizzBuzz. Plus précisément, les fonctions suivantes sont implémentées.
Le ** score ** indique ici la qualité de chaque réponse (nombre, FIzz, Buzz, FizzBuzz) à la situation actuelle pour l'IA. L'IA grandira dans le but de continuer à marquer ce score.
FizzBuzz.py
from random import randint
from numpy import array
class FizzBuzz:
def __init__(self, start, end):
self.start = start #Le début
self.end = end #la fin
def reset(self): #Initialisation
self.turn = self.start #Numéros actuels
self.state = [] #État actuel
#Définir le statut initial(15 derniers tours)
for i in range(self.turn - 15, self.turn):
if i % 15 == 0:
self.state.append(3)
elif i % 3 == 0:
self.state.append(1)
elif i % 5 == 0:
self.state.append(2)
else:
self.state.append(0)
#Si vous avez suffisamment appris
def is_learned(self):
return self.turn == self.end
#Transition de virage
def step(self, action, verbose=False):
if verbose:
print(self.turn, [self.turn, 'Fizz', 'Buzz', 'FizzBuzz'][action])
reward = 0 #But
terminal = False #Jugement de fin de partie
self.state = self.state[1:] + [action]
if action == 1: # Fizz
if self.turn % 3 == 0 and self.turn % 5 != 0:
reward = 1
terminal = False
else:
reward = -1
terminal = True
elif action == 2: # Buzz
if self.turn % 5 == 0 and self.turn % 3 != 0:
reward = 1
terminal = False
else:
reward = -1
terminal = True
elif action == 3: # FizzBuzz
if self.turn % 15 == 0:
reward = 1
terminal = False
else:
reward = -1
terminal = True
else: # Number
if self.turn % 3 != 0 and self.turn % 5 != 0:
reward = 1
terminal = False
else:
reward = -1
terminal = True
if self.turn == self.end:
terminal = True
self.turn += 1
return array(self.state), reward, terminal
def random_step(self): #Pour l'initialisation
return array(self.state), 0, False
Après l'initialisation avec reset (), l'apprentissage est répété pendant la transition avec l'étape (). De plus, j'ai écrit is_learned () pour juger de la fin afin que l'apprentissage puisse être automatiquement arrondi lorsque le jeu atteint le dernier nombre.
Ensuite, créez un ** modèle ** que vous utiliserez réellement pour l'apprentissage. Cette fois, nous utiliserons un réseau de neurones avec une structure plus simple dans la couche intermédiaire.
model.py
from keras.models import Sequential
from keras.layers import Dense, Reshape
from keras.optimizers import Adam
import numpy as np
class Model:
def __init__(self):
learning_rate = 0.01 #Taux d'apprentissage
state_size = 15 #Taille d'entrée(État actuel)
action_size = 4 #Taille de sortie(0, 1, 2, 3)
hidden_size = 16 #La taille du calque caché
self.model = Sequential()
self.model.add(Dense(hidden_size, activation='relu', input_dim=state_size))
self.model.add(Dense(action_size, activation='softmax'))
self.optimizer = Adam(lr=learning_rate)
self.model.compile(loss='mse', optimizer=self.optimizer)
self.model.summary()
#Fonctions à apprendre réellement
def replay(self, memory, batch_size, gamma, target_model):
inputs = np.zeros((batch_size, 15))
outputs = np.zeros((batch_size, 4))
mini_batch = memory.sample(batch_size)
for i, (state, action, reward, next_state) in enumerate(mini_batch):
inputs[i:i + 1] = state
target = reward
if not (next_state == np.zeros(state.shape)).all():
q = self.model.predict(next_state.reshape(1, 15))[0].argmax()
next_action = np.argmax(q) #Sélectionnez l'action avec la valeur Q la plus élevée comme action suivante
target = reward + gamma * target_model.model.predict(
next_state.reshape(1, 15)
)[0][next_action] #Récompense réelle
#Corrigez la valeur attendue actuelle et laissez-la apprendre
outputs[i] = self.model.predict(state.reshape(1, 15))
outputs[i][action.argmax()] = target
self.model.fit(inputs, outputs, epochs=1, verbose=0)
Utilisez replay () lors de l'apprentissage. Si vous vous entraînez à chaque tour, le modèle sera affecté par la série chronologique de données, donc une certaine quantité de données sera stockée dans la ** mémoire ** qui sera implémentée plus tard, et elle en sera extraite au hasard pour l'entraînement. Je vais.
Implémentez une mémoire pour stocker les données utilisées pour l'apprentissage.
memory.py
from collections import deque
import numpy as np
class Memory:
def __init__(self):
self.buffer = deque()
#Stocke la situation actuelle, son fonctionnement, ce qui s'est passé à la suite et la récompense pour cette action
def add(self, exp):
self.buffer.append(exp)
#Récupérer des données stockées au hasard
def sample(self, batch_size):
indice = np.random.choice(np.arange(len(self.buffer)), size=batch_size, replace=False)
return [self.buffer[i] for i in indice]
Une personne (?) Qui décide réellement d'une action pendant l'apprentissage et apprend en fonction du résultat est appelée un ** agent **.
agent.py
import numpy as np
from keras.utils.np_utils import to_categorical
class Agent:
#Choisissez une action
def get_action(self, state, epoch, main_model):
epsilon = 0.001 + 0.9 / (1.0 + epoch)
if epsilon < np.random.uniform(0, 1):
action = main_model.model.predict(state.reshape(1, 15))[0].argmax()
else: #Comportement aléatoire avec une certaine probabilité
action = np.random.choice([0, 1, 2, 3])
return to_categorical(action, 4)
Sélectionnez l'action avec get_action (). En gros, le comportement attendu par le modèle est sélectionné, mais en effectuant des mouvements aléatoires avec une certaine probabilité, il est possible de faire une soi-disant ** aventure ** et de découvrir un nouveau bon coup.
Tournons l'apprentissage en utilisant les personnes implémentées ci-dessus.
train.py
from fizzbuzz import FizzBuzz
from model import Model
from memory import Memory
from agent import Agent
def evaluate(env):
env.reset()
state, _, finished = env.random_step()
while not finished:
action = agent.get_action(state, N_EPOCHS, main_model)
next_state, _, finished = env.step(action.argmax(), verbose=True)
state = next_state
if __name__ == '__main__':
N_EPOCHS = 5000 #Nombre maximum de formations
S_BATCH = 4 #Taille du lot
GAMMA = 0.99 #Taux de réduction des récompenses au fil du temps
env = FizzBuzz(1, 1000) #Environnement d'apprentissage
main_model = Model()
target_model = Model()
memory = Memory() #Mémoire
agent = Agent() #Agent
learned_flag = False #Si l'apprentissage est terminé
for epoch in range(N_EPOCHS):
if learned_flag:
break
print('Epoch: {}'.format(epoch + 1))
#Réglage de l'état initial
env.reset()
state, reward, finished = env.random_step()
target_model.model.set_weights(main_model.model.get_weights())
while not finished:
action = agent.get_action(state, epoch, main_model)
learned_flag = env.is_learned()
next_state, reward, finished = env.step(action.argmax())
memory.add((state, action, reward, next_state))
state = next_state
if len(memory.buffer) > S_BATCH:
main_model.replay(memory, S_BATCH, GAMMA, target_model)
target_model.model.set_weights(main_model.model.get_weights())
env = FizzBuzz(1, 100)
evaluate(env)
Nous avons également implémenté evaluer () pour évaluer en fin d'apprentissage. Vous pouvez le vérifier lors de la sortie de FizzBuzz.
C'est un résultat d'apprentissage.
Epoch: 70
Epoch: 71
Epoch: 72
1 1, 2 2, 3 Fizz, 4 4, 5 Buzz, 6 Fizz, 7 7, 8 8, 9 Fizz, 10 Buzz, 11 11, 12 Fizz, 13 13, 14 14,
15 FizzBuzz, 16 16, 17 17, 18 Fizz, 19 19, 20 Buzz, 21 Fizz, 22 22, 23 23, 24 Fizz, 25 Buzz, 26 26,
27 Fizz, 28 28, 29 29, 30 FizzBuzz, 31 31, 32 32, 33 Fizz, 34 34, 35 Buzz, 36 Fizz, 37 37, 38 38,
39 Fizz, 40 Buzz, 41 41, 42 Fizz, 43 43, 44 44, 45 FizzBuzz, 46 46, 47 47, 48 Fizz, 49 49, 50 Buzz,
51 Fizz, 52 52, 53 53, 54 Fizz, 55 Buzz, 56 56, 57 Fizz, 58 58, 59 59, 60 FizzBuzz, 61 61, 62 62,
63 Fizz, 64 64, 65 Buzz, 66 Fizz, 67 67, 68 68, 69 Fizz, 70 Buzz, 71 71, 72 Fizz, 73 73, 74 74,
75 FizzBuzz, 76 76, 77 77, 78 Fizz, 79 79, 80 Buzz, 81 Fizz, 82 82, 83 83, 84 Fizz, 85 Buzz, 86 86,
87 Fizz, 88 88, 89 89, 90 FizzBuzz, 91 91, 92 92, 93 Fizz, 94 94, 95 Buzz, 96 Fizz, 97 FizzBuzz,
98 98, 99 Fizz, 100 Buzz
Après 72 tours d'apprentissage, j'ai pu atteindre 1 à 100.
Essayons le résultat de 4000.
4000 Buzz, 4001 4001, 4002 Fizz, 4003 4003, 4004 4004, 4005 FizzBuzz, 4006 4006, 4007 4007, 4008 Fizz,
4009 4009, 4010 Buzz, 4011 Fizz, 4012 4012, 4013 4013, 4014 Fizz, 4015 Buzz, 4016 4016, 4017 Fizz,
4018 4018, 4019 4019, 4020 FizzBuzz, 4021 4021, 4022 4022, 4023 Fizz, 4024 4024, 4025 Buzz, 4026 Fizz,
4027 4027, 4028 4028, 4029 Fizz, 4030 Buzz, 4031 4031, 4032 Fizz, 4033 4033, 4034 4034, 4035 FizzBuzz,
4036 4036, 4037 4037, 4038 Fizz, 4039 4039, 4040 Buzz, 4041 Fizz, 4042 4042, 4043 4043, 4044 Fizz,
4045 Buzz, 4046 4046, 4047 Fizz, 4048 4048, 4049 4049, 4050 FizzBuzz, 4051 4051, 4052 4052, 4053 Fizz,
4054 4054, 4055 Buzz, 4056 Fizz, 4057 4057, 4058 4058, 4059 Fizz, 4060 Buzz, 4061 4061, 4062 Fizz,
4063 4063, 4064 4064, 4065 FizzBuzz, 4066 4066, 4067 4067, 4068 Fizz, 4069 4069, 4070 Buzz, 4071 Fizz,
4072 4072, 4073 4073, 4074 Fizz, 4075 Buzz, 4076 4076, 4077 Fizz, 4078 4078, 4079 4079, 4080 FizzBuzz,
4081 4081, 4082 4082, 4083 Fizz, 4084 4084, 4085 Buzz, 4086 Fizz, 4087 4087, 4088 4088, 4089 Fizz,
4090 Buzz, 4091 4091, 4092 Fizz, 4093 4093, 4094 4094, 4095 FizzBuzz, 4096 4096, 4097 4097, 4098 Fizz,
4099 4099, 4100 Buzz, 4101 Fizz, 4102 4102, 4103 4103, 4104 Fizz, 4105 Buzz, 4106 4106, 4107 Fizz,
4108 4108, 4109 4109, 4110 FizzBuzz, 4111 4111, 4112 4112, 4113 Fizz, 4114 4114, 4115 Buzz, 4116 Fizz,
4117 4117, 4118 4118, 4119 Fizz, 4120 Buzz, 4121 4121, 4122 Fizz, 4123 4123, 4124 4124, 4125 FizzBuzz,
4126 4126, 4127 4127, 4128 Fizz, 4129 4129, 4130 Buzz, 4131 Fizz, 4132 4132, 4133 4133, 4134 Fizz,
4135 Buzz, 4136 4136, 4137 Fizz, 4138 4138, 4139 4139, 4140 FizzBuzz, 4141 4141, 4142 4142, 4143 Fizz,
4144 4144, 4145 Buzz, 4146 Fizz, 4147 4147, 4148 4148, 4149 Fizz, 4150 Buzz, 4151 4151, 4152 Fizz,
4153 4153, 4154 4154, 4155 FizzBuzz, 4156 4156, 4157 4157, 4158 Fizz, 4159 4159, 4160 Buzz, 4161 Fizz,
4162 4162, 4163 4163, 4164 Fizz, 4165 Buzz, 4166 4166, 4167 Fizz, 4168 4168, 4169 4169, 4170 FizzBuzz,
4171 4171, 4172 4172, 4173 Fizz, 4174 Fizz
Dans le 174e 4174, la sortie de ** 4174 ** a été confondue avec ** Fizz **. Il ne devrait y avoir qu'une quinzaine de types d'états, alors je me demande pourquoi j'ai fait une erreur ...
Au fait, si vous ajoutez l'argument verbose = True à step () sur la 43ème ligne de train.py, vous pouvez voir comment il apprend tout en augmentant progressivement le nombre de tours. mignonne.
Si vous le souhaitez, veuillez suivre Twitter. À plus.
Recommended Posts