Kuinka käyttää tekoälyä Sonic the Hedgehog -pelissä. Se on MATKA!

Sukupolvelta toiselle ihmiset ovat sopeutuneet sovitumaan paremmin ympäristöön. Aloitimme kädellisinä elämällä syömisen tai syömisen maailmassa. Lopulta meistä kehittyi kuka olemme tänään, mikä heijastaa modernia yhteiskuntaa. Evoluutioprosessin kautta meistä tulee älykkäämpiä. Pystymme työskentelemään paremmin ympäristön kanssa ja saavuttamaan tarvitsemamme.

Kehityksen kautta oppimisen käsitettä voidaan soveltaa myös tekoälyyn. Voimme kouluttaa tekoälyjä suorittamaan tiettyjä tehtäviä käyttämällä NEAT, Augro-topologioiden neurovoluutio. Yksinkertaisesti sanottuna NEAT on algoritmi, joka vie erän tekoälyjä (genomeja) yrittäen suorittaa tietyn tehtävän. Parhaiten menestyvät tekoälyt “kasvattavat” uuden sukupolven luomiseksi. Tämä prosessi jatkuu, kunnes meillä on sukupolvi, joka kykenee toteuttamaan tarvittavan.

NEAT on hämmästyttävä, koska se eliminoi tarpeen jo olemassa oleville tiedoille, joita tarvitaan tekoälyjen kouluttamiseen. Käyttäen NEAT: n ja OpenAI: n Gym Retron voimaa koulutin tekoälyn soittamaan Sonic the Hedgehogia SEGA Genesikselle. Opitaan miten!

NEAT-hermoverkko (Python-toteutus)

GitHub-arkisto

Vedant-Gupta523 / sonicNEAT

Osallistu Vedant-Gupta523 / sonicNEAT-kehitykseen luomalla tili GitHubiin. github.com

Huomaa: Kaikki tämän artikkelin koodi ja yllä oleva repo ovat hieman muokattu versio Lucas Thompsonin Sonic AI Botista, joka käyttää Open-AI- ja NEAT-YouTube-oppaita ja -koodia.

Ymmärtäminen OpenAI Gym

Jos et ole vielä perehtynyt OpenAI Gym -keskukseen, tutustu alla olevaan terminologiaan. Niitä käytetään usein koko artikkelissa.

agentti - tekoälysoitin. Tässä tapauksessa se on Sonic.

ympäristö - Agentin koko ympäristö. Peliympäristö.

toiminta - Jotain agentilla on mahdollisuus tehdä (eli liikkua vasemmalle, liikkua oikealle, hypätä, tehdä mitään).

vaihe - Suoritetaan yksi toiminto.

tila - Ympäristön kehys. Tekoälyn nykyinen tilanne.

havainto - mitä tekoäly havaitsee ympäristöstä.

kunto - Kuinka hyvin tekoälymme toimii.

valmis - Kun tekoäly on suorittanut tehtävänsä tai ei voi jatkaa.

Asennetaan riippuvuuksia

Alla on GitHub-linkit OpenAI: lle ja NEAT: lle asennusohjeilla.

OpenAI : //github.com/openai/retro

NEAT : //github.com/CodeReclaimers/neat-python

Pip-asennuskirjastot , kuten cv2, numpy, suolakurkku jne.

Tuo kirjastot ja aseta ympäristö

Aluksi meidän on tuotava kaikki käyttämämme moduulit:

import retro import numpy as np import cv2 import neat import pickle

Määritämme myös ympäristömme, joka koostuu pelistä ja tilasta:

env = retro.make(game = "SonicTheHedgehog-Genesis", state = "GreenHillZone.Act1")

Kun haluat kouluttaa tekoälyn pelaamaan Sonic the Hedgehogia, tarvitset pelin ROM-levyn (pelitiedosto). Yksinkertaisin tapa saada se on ostaa peli Steamista 5 dollaria. Löydät myös ilmaisia ​​ROM-latauksia verkossa, mutta se on laitonta, joten älä tee tätä.

OpenAI-arkistosta osoitteesta retro / retro / data / stabil / löydät kansion Sonic the Hedgehog Genesikselle. Aseta pelin ROM tähän ja varmista, että sitä kutsutaan rom.md. Tämä kansio sisältää myös .state-tiedostoja. Voit valita yhden ja asettaa tilaparametrin yhtä suureksi. Valitsin GreenHillZone Act 1, koska se on pelin ensimmäinen taso.

Tietojen data.json ja scenario.json ymmärtäminen

Sonic the Hedgehog -kansiossa on nämä kaksi tiedostoa:

data.json

{ "info": { "act":  "address": 16776721, "type": ", "level_end_bonus":  "address": 16775126, "type": ", "lives":  "address": 16776722, "type": ", "rings": { "address": 16776736, "type": ">u2" }, "score": { "address": 16776742, "type": ">u4" }, "screen_x": { "address": 16774912, "type": ">u2" }, "screen_x_end": { "address": 16774954, "type": ">u2" }, "screen_y": { "address": 16774916, "type": ">u2" }, "x": { "address": 16764936, "type": ">i2" }, "y": { "address": 16764940, "type": ">u2" }, "zone": u1"  } }

scenario.json

{ "done": { "variables": { "lives": { "op": "zero" } } }, "reward": { "variables": { "x": { "reward": 10.0 } } } }

Molemmat tiedostot sisältävät tärkeitä tietoja pelistä ja sen harjoittelusta.

Kuten kuulostaa, data.json-tiedosto sisältää tietoja / tietoja erilaisista pelikohtaisista muuttujista (esim. Sonicin x-sijainti, hänen elämiensä määrä jne.).

Scenaario.json-tiedoston avulla voimme suorittaa toimia synkronoituna tietomuuttujien arvojen kanssa. Esimerkiksi voimme palkita Sonic 10.0: n joka kerta, kun hänen x-asemansa kasvaa. Voisimme myös asettaa tekemämme ehdon tosi, kun Sonicin elämä osui 0.

NEAT-syötteen määrityksen ymmärtäminen

Config-feedforward-tiedosto löytyy yllä linkitetystä GitHub-arkistostani. Se toimii kuin asetusvalikko koulutuksen asettamiseksi. Muutama yksinkertainen asetus:

fitness_threshold = 10000 # How fit we want Sonic to become pop_size = 20 # How many Sonics per generation num_inputs = 1120 # Number of inputs into our model num_outputs = 12 # 12 buttons on Genesis controller

Voit kokeilla monia asetuksia nähdäksesi, miten se vaikuttaa tekoälyn harjoitteluun! Jos haluat oppia lisää NEAT: sta ja syötetavan kokoonpanon eri asetuksista, suosittelen, että luet ohjeet täältä

Putting it all together: Creating the Training File

Setting up configuration

Our feedforward configuration is defined and stored in the variable config.

config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, 'config-feedforward')

Creating a function to evaluate each genome

We start by creating the function, eval_genomes, which will evaluate our genomes (a genome could be compared to 1 Sonic in a population of Sonics). For each genome we reset the environment and take a random action

for genome_id, genome in genomes: ob = env.reset() ac = env.action_space.sample()

We will also record the game environment’s length and width and color. We divide the length and width by 8.

inx, iny, inc = env.observation_space.shape inx = int(inx/8) iny = int(iny/8)

We create a recurrent neural network (RNN) using the NEAT library and input the genome and our chosen configuration.

net = neat.nn.recurrent.RecurrentNetwork.create(genome, config)

Finally, we define a few variables: current_max_fitness (the highest fitness in the current population), fitness_current (the current fitness of the genome), frame (the frame count), counter (to count the number of steps our agent takes), xpos (the x-position of Sonic), and done (whether or not we have reached our fitness goal).

current_max_fitness = 0 fitness_current = 0 frame = 0 counter = 0 xpos = 0 done = False

While we have not reached our done requirement, we need to run the environment, increment our frame counter, and shape our observation to mimic that of the game (still for each genome).

env.render() frame += 1 ob = cv2.resize(ob, (inx, iny)) ob = cv2.cvtColor(ob, cv2.COLOR_BGR2GRAY) ob = np.reshape(ob, (inx,iny))

We will take our observation and put it in a one-dimensional array, so that our RNN can understand it. We receive our output by feeding this array to our RNN.

imgarray = [] imgarray = np.ndarray.flatten(ob) nnOutput = net.activate(imgarray)

Using the output from the RNN our AI takes a step. From this step we can extract fresh information: a new observation, a reward, whether or not we have reached our done requirement, and information on variables in our data.json (info).

ob, rew, done, info = env.step(nnOutput)

At this point we need to evaluate our genome’s fitness and whether or not it has met the done requirement.

We look at our “x” variable from data.json and check if it has surpassed the length of the level. If it has, we will increase our fitness by our fitness threshold signifying we are done.

xpos = info['x'] if xpos >= 10000: fitness_current += 10000 done = True

Otherwise, we will increase our current fitness by the reward we earned from performing the step. We also check if we have a new highest fitness and adjust the value of our current_max_fitness accordingly.

fitness_current += rew if fitness_current > current_max_fitness: current_max_fitness = fitness_current counter = 0 else: counter += 1

Lastly, we check if we are done or if our genome has taken 250 steps. If so, we print information on the genome which was simulated. Otherwise we keep looping until one of the two requirements has been satisfied.

if done or counter == 250: done = True print(genome_id, fitness_current) genome.fitness = fitness_current

Defining the population, printing training stats, and more

The absolute last thing we need to do is define our population, print out statistics from our training, save checkpoints (in case you want to pause and resume training), and pickle our winning genome.

p = neat.Population(config) p.add_reporter(neat.StdOutReporter(True)) stats = neat.StatisticsReporter() p.add_reporter(stats) p.add_reporter(neat.Checkpointer(1)) winner = p.run(eval_genomes) with open('winner.pkl', 'wb') as output: pickle.dump(winner, output, 1)

All that’s left is the matter of running the program and watching Sonic slowly learn how to beat the level!

To see all of the code put together check out the Training.py file in my GitHub repository.

Bonus: Parallel Training

If you have a multi-core CPU you can run multiple training simulations at once, exponentially increasing the rate at which you can train your AI! Although I will not go through the specifics on how to do this in this article, I highly suggest you check the sonicTraning.py implementation in my GitHub repository.

Conclusion

That’s all there is to it! With a few adjustments, this framework is applicable to any game for the NES, SNES, SEGA Genesis, and more. If you have any questions or you just want to say hello, feel free to email me at vedantgupta523[at]gmail[dot]com ?

Also, be sure to check out Lucas Thompson's Sonic AI Bot Using Open-AI and NEAT YouTube tutorials and code to see what originally inspired this article.

Key Takeaways

  1. Augmenting Topologies Neuroevolution of Augmenting Topologies (NEAT) on algoritmi, jota käytetään tekoälyn kouluttamiseen tiettyjen tehtävien suorittamiseen. Se on mallinnettu geneettisen evoluution jälkeen.
  2. NEAT eliminoi jo olemassa olevan datan tarpeen AI-koulutuksessa.
  3. OpenAI: n ja NEAT: n käyttöönoton prosessiPython kouluttaa tekoälyä pelaamaan mitä tahansa peliä.