Sukelletaan syvällisesti vahvistusoppimiseen. Tässä artikkelissa käsittelemme konkreettista ongelmaa nykyaikaisissa kirjastoissa, kuten TensorFlow, TensorBoard, Keras ja OpenAI-kuntosali. Näet kuinka toteuttaa yksi perusalgoritmeista nimeltä syvä $ Q $ -oppiminen oppimaan sen sisäinen toiminta. Laitteiston osalta koko koodi toimii tyypillisessä tietokoneessa ja käyttää kaikkia löydettyjä suorittimen ytimiä (tämän käsittelee TensorFlow laatikosta).

Ongelmaa kutsutaan Mountain Car: Auto on yksiulotteisella radalla kahden vuoren välissä. Tavoitteena on ajaa ylös oikealle vuorelle (saavuttaa lippu). Auton moottori ei kuitenkaan ole tarpeeksi vahva kiipeämään vuorelle yhdellä kertaa. Siksi ainoa tapa menestyä on ajaa edestakaisin vauhdin kasvattamiseksi.

Tämä ongelma valittiin, koska se on riittävän yksinkertainen löytää ratkaisu vahvistuksen oppimisen kanssa muutamassa minuutissa yhdellä suorittimen ytimellä. Se on kuitenkin riittävän monimutkainen ollakseen hyvä edustaja.

Ensin annan lyhyen yhteenvedon siitä, mitä vahvistava oppiminen yleensä tekee. Sitten käsittelemme perustermit ja ilmaisemme ongelmamme niiden kanssa. Sen jälkeen kuvaan syvällisen $ Q $ -lukuoppimisalgoritmin ja toteutamme sen ongelman ratkaisemiseksi.

Vahvistuksen oppimisen perusteet

Vahvistava oppiminen yksinkertaisimmilla sanoilla on oppiminen kokeilemalla ja erehdyksellä. Päähenkilöä kutsutaan 'agentiksi', joka olisi auto ongelmassamme. Agentti tekee toiminnan ympäristössä ja hänelle palautetaan uusi havainto ja palkkio siitä. Suurempiin palkintoihin johtavat toimet vahvistuvat, joten nimi. Kuten monien muiden tietojenkäsittelytieteiden kohdalla, tämäkin inspiroi elävien olentojen tarkkailua.

Agentin vuorovaikutus ympäristön kanssa on koottu seuraavaan kaavioon:

Agentti saa havainnon ja palkkion suoritetusta toiminnosta. Sitten se tekee uuden toiminnon ja ottaa toisen vaiheen. Ympäristö palauttaa nyt (todennäköisesti) hieman erilaisen havainnon ja palkkion. Tämä jatkuu, kunnes päätelaite on saavutettu, josta ilmoitetaan lähettämällä 'valmis' agentille. Koko sarja havainnot> toimet> seuraavat havainnot> palkkiot kutsutaan jaksoksi (tai liikeradaksi).

Palataan Mountain Cariin: automme on agentti. Ympäristö on yksiulotteisten vuorten mustan laatikon maailma. Auton toiminta on vain yksi luku: jos positiivinen, moottori työntää auton oikealle. Jos negatiivinen, se työntää autoa vasemmalle. Agentti havaitsee ympäristön havainnon kautta: auton X-sijainti ja nopeus. Jos haluamme, että automme ajaa vuoren huipulle, määritämme palkkion kätevällä tavalla: Agentti saa -1 palkintoonsa jokaisesta askeleesta, jossa se ei ole saavuttanut tavoitetta. Kun se saavuttaa tavoitteen, jakso päättyy. Joten itse asiassa agentti rangaistaan ​​siitä, ettei hän ole tilanteessa, jonka haluamme sen olevan. Mitä nopeammin hän saavuttaa sen, sitä parempi hänelle. Agentin tavoitteena on maksimoida kokonaispalkinto, joka on yhden jakson palkintojen summa. Joten jos se saavuttaa halutun pisteen esimerkiksi 110 askeleen jälkeen, se saa kokonaistuoton -110, mikä olisi loistava tulos Mountain Carille, koska jos se ei saavuta tavoitetta, sitä rangaistaan ​​200 askeleella (siis paluu -200).

Tämä on koko ongelman muotoilu. Nyt voimme antaa sen algoritmeille, jotka ovat jo riittävän tehokkaita ratkaisemaan tällaiset ongelmat muutamassa minuutissa (jos ne on hyvin viritetty). On syytä huomata, että emme kerro edustajalle, miten saavuttaa tavoite. Emme edes anna vihjeitä (heuristiikka). Agentti löytää tavan (politiikan) voittaa itse.

Ympäristön asettaminen

Kopioi ensin koko opetusohjelma koodi levylle:

git clone https://github.com/AdamStelmaszczyk/rl-tutorial cd rl-tutorial

Nyt meidän on asennettava Python-paketit, joita käytämme. Jos emme asenna niitä käyttäjäalueellesi (ja vaarassa olla törmäyksiä), teemme sen puhtaaksi ja asennamme ne conda-ympäristöön. Jos asuntoa ei ole asennettu, noudata ohjeita https://conda.io/docs/user-guide/install/index.html .

Conda-ympäristön luominen:

conda create -n tutorial python=3.6.5 -y

Aktivoi se:

source activate tutorial

Sinun pitäisi nähdä (tutorial) lähellä komentoa kuoressa. Se tarkoittaa, että conda-ympäristö nimeltä 'tutorial' on aktiivinen. Tästä lähtien kaikki komennot tulisi suorittaa kyseisessä conda-ympäristössä.

Nyt voimme asentaa kaikki riippuvuudet hermeettiseen conda-ympäristöön:

pip install -r requirements.txt

Asennus on valmis, joten ajetaan koodi. Meidän ei tarvitse toteuttaa Mountain Car -ympäristöä itse; OpenAI Gym -kirjasto tarjoaa kyseisen toteutuksen. Katsotaanpa satunnainen agentti (agentti, joka suorittaa satunnaisia ​​toimia) ympäristössämme:

import gym env = gym.make('MountainCar-v0') done = True episode = 0 episode_return = 0.0 for episode in range(5): for step in range(200): if done: if episode > 0: print('Episode return: ', episode_return) obs = env.reset() episode += 1 episode_return = 0.0 env.render() else: obs = next_obs action = env.action_space.sample() next_obs, reward, done, _ = env.step(action) episode_return += reward env.render()

Tämä on see.py tiedosto; Suorita se suorittamalla:

python see.py

Sinun pitäisi nähdä auto menemässä satunnaisesti edestakaisin. Jokainen jakso koostuu 200 vaiheesta; kokonaistuotto on -200.

Nyt meidän on korvattava satunnaiset toimet jollakin paremmalla. On monia algoritmeja, joita voisi käyttää. Aloitusoppaassa mielestäni lähestymistapa, jota kutsutaan syvälle $ Q $ -luokitukselle, sopii hyvin. Menetelmän ymmärtäminen antaa vankan perustan muiden lähestymistapojen oppimiselle.

Syvä $ Q $ -oppiminen

Algoritmia, jota käytämme, kuvasivat ensimmäisen kerran vuonna 2013 Mnih et ai. sisään Atarin soittaminen syvävahvistusoppimisen avulla ja kiillotettu kaksi vuotta myöhemmin vuonna Ihmisen tason hallinta syvällisen vahvistamisen avulla . Näihin tuloksiin on rakennettu monia muita teoksia, mukaan lukien nykyinen huipputekniikan algoritmi Sateenkaari (2017):

Rainbow saavuttaa yli-inhimillisen suorituskyvyn monissa Atari 2600 -peleissä. Keskitymme DQN-perusversioon mahdollisimman pienellä määrällä lisäparannuksia pitämään tämä opetusohjelma kohtuullisessa koossa.

Käytäntö, jota yleensä merkitään $ π (s) $, on funktio, joka palauttaa todennäköisyydet yksittäisten toimintojen suorittamiseksi tietyssä tilassa $ s $. Joten esimerkiksi satunnainen Mountain Car -politiikka palaa mihin tahansa valtioon: 50% vasemmalle, 50% oikealle. Pelin aikana otamme käytännön (jakelu) ottaaksemme todellisia toimia.

$ Q $ -learning (Q tarkoittaa laatua) viittaa toiminta-arvo-funktioon, jota merkitään $ Q_π (s, a) $. Se palauttaa kokonaistuoton tietystä osavaltiosta $ s $ ja valitsee toiminnon $ a $ noudattaen konkreettista käytäntöä $ π $. Kokonaistuotto on kaikkien jaksojen (lentorata) kaikkien palkkioiden summa.

Jos tiedämme optimaalisen $ Q $ -funktion, jota merkitään $ Q ^ * $, voimme ratkaista pelin helposti. Seuraamme vain toimia, joiden arvo on korkein $ Q ^ * $, eli suurin odotettu tuotto. Tämä takaa, että saavutamme korkeimman mahdollisen tuoton.

Emme kuitenkaan usein tiedä $ Q ^ * $. Tällaisissa tapauksissa voimme arvioida - tai 'oppia' - vuorovaikutuksesta ympäristön kanssa. Tämä on nimessä ”$ Q $ -learning” -osa. Siinä on myös sana 'syvä', koska funktion arvioimiseksi käytämme syviä hermoverkkoja, jotka ovat universaalisia funktion lähentäjiä. Syvät hermoverkot, jotka arvioivat $ Q $ -arvot, nimettiin Deep Q-Networks (DQN). Yksinkertaisissa ympäristöissä (kun muistiin sopiva tilojen määrä) voidaan vain käyttää taulukkoa hermoverkon sijaan $ Q $ -funktion edustamiseksi, jolloin se nimetään 'taulukkomaiseksi $ Q $ -oppimiseksi'.

Joten tavoitteemme on nyt arvioida $ Q ^ * $ -funktio. Käytämme Bellman-yhtälöä:

[Q (s, a) = r + γ väli textrm {max} _ {a '} Q (s', a ') ]

$ s ’$ on tila $ s $: n jälkeen. $ γ $ (gamma), tyypillisesti 0,99, on alennustekijä (se on hyperparametri). Se asettaa pienemmän painon tuleville palkinnoille (koska ne ovat vähemmän varmoja kuin välittömät palkkiot epätäydellisellä $ Q $: lla). Bellman-yhtälö on keskeinen osa syvää $ Q $ -oppimista. Siinä sanotaan, että $ Q $ -arvo tietylle valtiolle ja toiminnalle on palkkio $ r $, joka on saatu toiminnan $ a $ jälkeen lisää korkein $ Q $ -arvo osavaltiolle, johon laskeutumme $ s ’$. Suurin on tavallaan, että valitsemme toiminnon $ a ’$, mikä johtaa korkeimpaan kokonaistuottoon $ s’ $: sta.

Bellman-yhtälön avulla voimme käyttää valvottua oppimista arvioimaan $ Q ^ * $. Funktio $ Q $ esitetään (parametrisoidaan) hermoverkkopainoilla, jotka merkitään nimellä $ θ $ (theta). Suoraviivainen toteutus edellyttäisi tilaa ja toimintoa verkon syötteenä ja Q-arvon antamisena. Tehottomuus on, että jos haluamme tietää $ Q $ -arvot kaikille toiminnoille tietyssä tilassa, meidän on soitettava $ Q $ niin monta kertaa kuin on toimintoja. On paljon parempi tapa: ottaa vain tila sisääntuloksi ja tulostaa $ Q $ -arvot kaikille mahdollisille toiminnoille. Tämän ansiosta voimme saada $ Q $ -arvot kaikille toiminnoille yhdellä eteenpäin.

Aloitamme $ Q $ -verkon harjoittamisen satunnaispainoilla. Ympäristöstä saamme monia siirtymiä (tai 'kokemuksia'). Nämä ovat joukkoa (osavaltio, toiminta, seuraava tila, palkkio) tai lyhyesti sanottuna ($ s $, $ a $, $ s ’$, $ r $). Tallennamme tuhansia niistä rengaspuskuriin, jota kutsutaan 'kokemusten toistoksi'. Sitten otamme kokemuksia tuosta puskurista toiveella, jonka Bellman-yhtälö pitää heille paikkansa. Olisimme voineet ohittaa puskurin ja käyttää kokemuksia yksitellen (tätä kutsutaan 'online' tai 'on-policy'); ongelmana on, että myöhemmät kokemukset korreloivat voimakkaasti toistensa kanssa ja DQN kouluttaa huonosti, kun tämä tapahtuu. Siksi kokemusten uudelleentoisto otettiin käyttöön ('offline', 'politiikan ulkopuolinen' lähestymistapa) tietojen korrelaation poistamiseksi. Yksinkertaisimman rengaspuskurin toteutuksen koodi löytyy replay_buffer.py -sivulta kannustan sinua lukemaan sen.

Aluksi, koska hermoverkkopainomme olivat satunnaisia, Bellman-yhtälön vasemmanpuoleinen arvo on kaukana oikeanpuoleisesta. Neliöero on häviöfunktiomme. Pienennämme menetystoiminnon muuttamalla hermoverkon painoja $ θ $. Kirjoita muistiin tappiotoiminto:

[L (θ) = [Q (s, a) - r - γ väli textrm {max} _ {a '} Q (s', a ')] ^ 2 ]

Se on kirjoitettu Bellman-yhtälö. Oletetaan, että otimme kokemuksen ($ s $, vasen, $ s ’$, -1) Mountain Car -kokemuksesta. Käymme eteenpäin $ Q $ -verkostomme läpi valtion $ s $ kanssa ja vasemmalle toiminnalle se antaa esimerkiksi -120. Joten, $ Q (s, textrm {vasen}) = -120 $. Sitten syötämme $ s: n $ verkkoon, mikä antaa meille esim. -130 vasemmalle ja -122 oikealle. Joten $ s ’$: n paras toiminto on oikein, joten $ textrm {max} _ {a’} Q (s ’, a’) = -122 $. Tiedämme $ r $, tämä on todellinen palkkio, joka oli -1. Joten $ Q $ -verkkoennusteemme oli hieman väärä, koska $ L (θ) = [-120 - 1 + 0,99 ⋅ 122] ^ 2 = (-0,22 ^ 2) = 0,0484 $. Joten levitämme virhettä taaksepäin ja korjaamme painot $ θ $ hieman. Jos laskemme tappion uudelleen samalle kokemukselle, se olisi nyt pienempi.

Yksi tärkeä havainto ennen koodiin siirtymistä. Huomaa, että DQN: n päivittämiseksi teemme kaksi eteenpäinpääsyä DQN: lle ... itse. Tämä johtaa usein epävakaaseen oppimiseen. Tämän lievittämiseksi emme käytä samaa DQN-arvoa seuraavassa osavaltiossa $ Q $. Käytämme sen vanhempaa versiota, jota koodissa kutsutaan target_model (sen sijaan, että model olisi tärkein DQN). Tämän ansiosta meillä on vakaa kohde. Päivitämme target_model asettamalla se arvoon model painot 1000 askeleen välein. Mutta model päivittää jokainen askel.

Katsotaanpa koodia, joka luo DQN-mallin:

def create_model(env): n_actions = env.action_space.n obs_shape = env.observation_space.shape observations_input = keras.layers.Input(obs_shape, name='observations_input') action_mask = keras.layers.Input((n_actions,), name='action_mask') hidden = keras.layers.Dense(32, activation='relu')(observations_input) hidden_2 = keras.layers.Dense(32, activation='relu')(hidden) output = keras.layers.Dense(n_actions)(hidden_2) filtered_output = keras.layers.multiply([output, action_mask]) model = keras.models.Model([observations_input, action_mask], filtered_output) optimizer = keras.optimizers.Adam(lr=LEARNING_RATE, clipnorm=1.0) model.compile(optimizer, loss='mean_squared_error') return model

Ensinnäkin toiminto ottaa toiminta- ja havainnointitilan mitat tietystä OpenAI Gym -ympäristöstä. On esimerkiksi tiedettävä, kuinka monta lähtöä verkollamme on. Sen on oltava yhtä suuri kuin toimintojen lukumäärä. Toiminnot ovat yksi pikakoodattu:

def one_hot_encode(n, action): one_hot = np.zeros(n) one_hot[int(action)] = 1 return one_hot

Joten (esim.) Vasen on [1, 0] ja oikea on [0, 1].

Voimme nähdä, että havainnot välitetään syötteenä. Ohitamme myös action_mask toisena tulona. Miksi? Laskettaessa $ Q (s, a) $, meidän on tiedettävä $ Q $ -arvo vain yhdelle annetulle toiminnolle, ei kaikille. action_mask sisältää 1 toiminnoille, jotka haluamme välittää DQN-lähdölle. Jos action_mask on 0 joillekin toiminnoille, vastaava $ Q $ -arvo nollataan tuloksessa. filtered_output kerros tekee niin. Jos haluamme kaikki $ Q $ -arvot (maks. Laskelmia varten), voimme vain siirtää kaikki.

Koodi käyttää keras.layers.Dense määrittää täysin yhdistetyn kerroksen. Keras on Python-kirjasto korkeamman tason abstraktioon TensorFlow-sovelluksen päällä. Konepellin alle Keras luo TensorFlow-kaavion, jossa on esijännitteitä, oikea painon alustus ja muita matalan tason asioita. Olisimme voineet käyttää vain raakaa TensorFlow-kuvaajaa kuvaajan määrittelemiseen, mutta se ei ole yhden linjan.

Joten havainnot välitetään ensimmäiseen piilotettuun kerrokseen ReLU (rectified linear unit) -aktivaatioilla. ReLU(x) on vain $ textrm {max} (0, x) $ -funktio. Tämä kerros on täysin kytketty toiseen identtiseen kerrokseen hidden_2 Lähtökerros vähentää hermosolujen määrän toimintojen lukumäärään. Loppujen lopuksi meillä on filtered_output, joka vain kertoo tuloksen action_mask: lla.

Löydämme $ θ $ painot käyttämällä optimoijaa nimeltä “Adam”, jonka keskimääräinen virhehäviö on neliö.

Mallin avulla voimme ennustaa $ Q $ -arvoja tietyille tilan havainnoille:

def predict(env, model, observations): action_mask = np.ones((len(observations), env.action_space.n)) return model.predict(x=[observations, action_mask])

Haluamme $ Q $ -arvoja kaikille toiminnoille, siis action_mask on niiden vektori.

Varsinaiseen harjoitteluun käytämme fit_batch():

def fit_batch(env, model, target_model, batch): observations, actions, rewards, next_observations, dones = batch # Predict the Q values of the next states. Passing ones as the action mask. next_q_values = predict(env, target_model, next_observations) # The Q values of terminal states is 0 by definition. next_q_values[dones] = 0.0 # The Q values of each start state is the reward + gamma * the max next state Q value q_values = rewards + DISCOUNT_FACTOR_GAMMA * np.max(next_q_values, axis=1) one_hot_actions = np.array([one_hot_encode(env.action_space.n, action) for action in actions]) history = model.fit( x=[observations, one_hot_actions], y=one_hot_actions * q_values[:, None], batch_size=BATCH_SIZE, verbose=0, ) return history.history['loss'][0]

Erä sisältää BATCH_SIZE kokemukset. next_q_values on $ Q (s, a) $. q_values on $ r + γ space textrm {max} _ {a ’} Q (s’, a ’) $ Bellman-yhtälöstä. Suoritetut toiminnot on yksi pikakoodattu ja siirretty nimellä action_mask tuloon soitettaessa model.fit(). $ y $ on tavallinen kirjain 'tavoitteelle' valvotussa oppimisessa. Täällä ohitamme q_values. Teen q_values[:. None] lisätä matriisin ulottuvuutta, koska sen on vastattava one_hot_actions -ulottuvuutta taulukko. Tätä kutsutaan viipaleiksi, jos haluat lukea lisää siitä.

Palautamme häviön tallentamaan sen TensorBoard-lokitiedostoon ja visualisoimaan myöhemmin. Tarkkailemme monia muita asioita: kuinka monta askelta sekunnissa teemme, RAM-muistin kokonaiskäyttö, mikä on jaksojen keskimääräinen palautus jne. Katsotaanpa nuo juoni.

Juoksu

TensorBoard-lokitiedoston visualisoimiseksi tarvitsemme ensin sellaisen. Joten suoritetaan vain koulutus:

python run.py

Tämä tulostaa ensin mallin yhteenvedon. Sitten se luo lokihakemiston nykyisellä päivämäärällä ja aloittaa harjoittelun. Joka 2000 askelta tulostetaan logline tämän kaltaiseksi:

episode 10 steps 200/2001 loss 0.3346639 return -200.0 in 1.02s 195.7 steps/s 9.0/15.6 GB RAM

Joka 20 000, arvioimme mallimme 10000 askelella:

Evaluation 100%|█████████████████████████████████████████████████████████████████████████████████| 10000/10000 [00:07<00:00, 1254.40it/s] episode 677 step 120000 episode_return_avg -136.750 avg_max_q_value -56.004

677 jakson ja 120 000 vaiheen jälkeen keskimääräinen jakson paluu parani -200: sta -136,75: een! Se on ehdottomasti oppimista. Mitä avg_max_q_value jätänkö hyvän harjoituksen lukijalle. Mutta se on erittäin hyödyllinen tilasto tarkastella harjoittelun aikana.

200 000 askeleen jälkeen koulutus on suoritettu. Neljän ytimen suorittimellani se kestää noin 20 minuuttia. Voimme katsoa date-log hakemisto, esim. 06-07-18-39-log. Mallitiedostoja, joissa on .h5, on neljä laajennus. Tämä on tilannekuva TensorFlow-kaaviopainoista, tallennamme ne 50000 vaiheen välein, jotta voimme myöhemmin tarkastella oppimaamme käytäntöä. Voit tarkastella sitä:

python run.py --model 06-08-18-42-log/06-08-18-42-200000.h5 --view

Jos haluat nähdä muut mahdolliset liput: python run.py --help.

Nyt auto tekee paljon parempaa työtä tavoitellun tavoitteen saavuttamiseksi. Kohdassa date-log hakemistossa on myös events.out.* tiedosto. Tämä on tiedosto, johon TensorBoard tallentaa tietoja. Kirjoitamme sille yksinkertaisimmalla TensorBoardLogger määritelty kohdassa loggers.py. Tapahtumatiedoston tarkastelemiseksi meidän on suoritettava paikallinen TensorBoard-palvelin:

tensorboard --logdir=.

--logdir osoittaa vain hakemistoon, jossa on päivämäärälokihakemistoja, tapauksessamme tämä on nykyinen hakemisto, joten .. TensorBoard tulostaa URL-osoitteen, jota se kuuntelee. Jos avaat http://127.0.0.1:6006 , sinun pitäisi nähdä kahdeksan tonttia, jotka ovat samanlaisia ​​kuin nämä:

Käärimistä

train() tekee kaiken koulutuksen. Luomme ensin mallin ja toistamme puskurin uudelleen. Sitten vuorovaikutuksessa ympäristön kanssa ja tallennamme kokemuksia puskuriin silmukassa, joka on hyvin samanlainen kuin see.py Tärkeää on, että noudatamme epsilon-ahneita käytäntöjä. Voisimme aina valita parhaan toiminnan $ Q $ -funktion mukaan; Tämä kuitenkin estää etsintää, mikä vahingoittaa yleistä suorituskykyä. Joten epsilon-todennäköisyydellä toteutettavan etsinnän toteuttamiseksi suoritamme satunnaisia ​​toimia:

def greedy_action(env, model, observation): next_q_values = predict(env, model, observations=[observation]) return np.argmax(next_q_values) def epsilon_greedy_action(env, model, observation, epsilon): if random.random()

Epsilon asetettiin 1%: ksi. Vuoden 2000 kokemuksen jälkeen uusinta täyttyy tarpeeksi harjoittelun aloittamiseksi. Teemme sen soittamalla fit_batch() satunnaisella erällä kokemuksia, jotka on otettu näytteestä toistopuskurista:

batch = replay.sample(BATCH_SIZE) loss = fit_batch(env, model, target_model, batch)

Jokainen 20000 askelta arvioimme ja kirjaamme tulokset (arviointi on epsilon = 0, täysin ahne politiikka):

if step >= TRAIN_START and step % EVAL_EVERY == 0: episode_return_avg = evaluate(env, model) q_values = predict(env, model, q_validation_observations) max_q_values = np.max(q_values, axis=1) avg_max_q_value = np.mean(max_q_values) print( 'episode {} ' 'step {} ' 'episode_return_avg {:.3f} ' 'avg_max_q_value {:.3f}'.format( episode, step, episode_return_avg, avg_max_q_value, )) logger.log_scalar('episode_return_avg', episode_return_avg, step) logger.log_scalar('avg_max_q_value', avg_max_q_value, step)

Koko koodi on noin 300 riviä ja run.py sisältää noin 250 tärkeintä.

Voidaan huomata, että hyperparametreja on paljon:

DISCOUNT_FACTOR_GAMMA = 0.99 LEARNING_RATE = 0.001 BATCH_SIZE = 64 TARGET_UPDATE_EVERY = 1000 TRAIN_START = 2000 REPLAY_BUFFER_SIZE = 50000 MAX_STEPS = 200000 LOG_EVERY = 2000 SNAPSHOT_EVERY = 50000 EVAL_EVERY = 20000 EVAL_STEPS = 10000 EVAL_EPSILON = 0 TRAIN_EPSILON = 0.01 Q_VALIDATION_SIZE = 10000

Eikä siinä kaikki. Siellä on myös verkkoarkkitehtuuri - käytimme kahta piilotettua kerrosta, joissa oli 32 neuronia, ReLU-aktivaatioita ja Adam-optimoijaa, mutta on paljon muita vaihtoehtoja. Jopa pienillä muutoksilla voi olla valtava vaikutus koulutukseen. Hyperparametrien virittämiseen voidaan käyttää paljon aikaa. Äskettäisessä OpenAI-kilpailussa toisen sijan kilpailija saada selville se on mahdollista melkein kaksinkertainen Rainbow: n tulos hyperparametrien virityksen jälkeen. Luonnollisesti on muistettava, että se on helppo yliasentaa. Tällä hetkellä vahvistusalgoritmit kamppailevat tiedonsiirron kanssa samankaltaisiin ympäristöihin. Mountain Car -automme ei tällä hetkellä yleisty kaikentyyppisille vuorille. Voit itse muokata OpenAI Gym -ympäristöä ja nähdä, kuinka pitkälle agentti voi yleistää.

Toinen harjoitus on löytää paremmat hyperparametrit kuin minun. Se on ehdottomasti mahdollista. Yksi harjoittelu ei kuitenkaan riitä arvioimaan, onko muutoksesi parannus. Harjoitusajoissa on yleensä suuri ero; varianssi on suuri. Tarvitset useita ajoja selvittääksesi, että jokin on parempi. Jos haluat lukea lisää tärkeästä aiheesta kuten toistettavuus, kannustan sinua lukemaan Syvä vahvistaminen, jolla on merkitystä . Käsin virittämisen sijaan voimme automatisoida tämän prosessin jossain määrin - jos olemme valmiita käyttämään enemmän laskentatehoa ongelmaan. Yksinkertainen lähestymistapa on valmistaa lupaava arvoalue joillekin hyperparametreille ja suorittaa sitten ruudukkohaku (tarkistaa niiden yhdistelmät), kun harjoitukset suoritetaan rinnakkain. Rinnakkaistaminen itsessään on iso aihe, koska se on ratkaisevan tärkeää korkean suorituskyvyn kannalta.

Syvä $ Q $ -luokittelu edustaa suurta vahvistamisoppimisalgoritmien perhettä, joka käyttää arvon iterointia. Yritimme arvioida $ Q $ -funktiota ja käytimme sitä vain ahneella tavalla suurimman osan ajasta. On toinen perhe, joka käyttää politiikan iteraatiota. He eivät keskity $ Q $ -funktion lähentämiseen, vaan optimaalisen käytännön $ π ^ * $ löytämiseen. Jos haluat nähdä, missä arvon iterointi sopii vahvistusoppimisalgoritmien maisemaan:

Ajatuksesi voivat olla, että syvä vahvistusoppiminen näyttää hauraalta. Sinulla on oikeus; on monia ongelmia. Voit viitata Syvä vahvistaminen ei vielä toimi ja Vahvistusoppiminen ei koskaan toiminut, ja 'syvä' auttoi vain vähän .

Tämä viimeistelee opetusohjelman. Toteutimme oman perus-DQN: n oppimistarkoituksiin. Hyvin samanlainen koodi voidaan käyttää hyvän suorituskyvyn saavuttamiseksi joissakin Atari-peleissä. Käytännön sovelluksissa otetaan usein testatut, tehokkaat toteutukset, esimerkiksi yksi OpenAI-perusviivat . Jos haluat nähdä, mitä haasteita voi kohdata, kun yritetään soveltaa syvää vahvistamista oppimista monimutkaisemmassa ympäristössä, voit lukea NIPS 2017: Juoksemisen oppimisen lähestymistapa . Jos haluat oppia lisää hauskassa kilpailuympäristössä, katso asia NIPS 2018 -kilpailut tai joukko.org .

Jos olet matkalla tulossa koneoppiminen asiantuntija ja haluaisi syventää tietosi valvotussa oppimisessa, tarkista Koneoppiminen videoanalyysi: Kalojen tunnistaminen hauskasta kokeesta kalojen tunnistamiseksi.

Liittyvät: Flappy Birdin kouluttaminen: Vahvistusoppimisopetus

Perustietojen ymmärtäminen

Mikä on vahvistusoppiminen?

Vahvistusoppiminen on biologisesti inspiroima kokeiluversi-menetelmä agentin kouluttamiseksi. Palkitsemme edustajan hyvistä toimista halutun käyttäytymisen vahvistamiseksi. Rangaistimme myös huonoja toimia, jotta niitä tapahtuisi harvemmin.

Mikä on Q Q-oppimisessa?

Q tarkoittaa 'laatua'. Se viittaa toiminta-arvo-funktioon, jota merkitään Qπ (s, a). Se palauttaa kokonaistuoton tietystä tilasta s, valitsemalla toiminnan a, noudattamalla konkreettista politiikkaa π. Kokonaistuotto on kaikkien jaksojen kaikkien palkkioiden summa.

Mikä on Bellman-yhtälö?

Q (s, a) = r + y maxa'Q (s ', a'). Verbaalisesti: Q-arvo tietylle tilalle ja toiminnalle on palkkio r, joka saadaan toimenpiteen toteuttamisen jälkeen a + korkein Q-arvo tilalle, johon laskeutumme s '. Korkein siinä mielessä, että valitsemme toiminnan a, joka johtaa s: n suurimpaan kokonaistuottoon.

Mikä on Bellmanin optimaalisuusperiaate?

Optimaalisuuden periaate: Optimaalisella politiikalla on se ominaisuus, että riippumatta alkuperäisestä tilasta ja toimista, muiden toimien on muodostettava optimaalinen politiikka alkuperäisen toiminnan tuloksena olevan valtion suhteen. Sitä käytetään Q-oppimisessa, mutta yleensä kaikissa dynaamisissa ohjelmointitekniikoissa.

Mitkä ovat parametrit ja hyperparametrit?

Parametrit viittaavat malliparametreihin, joten jos käytetään hermoverkkoja, se viittaa niiden painoon. Tyypillisesti meillä on tuhansia tai miljoonia parametreja. Hyperparametreja käytetään oppimisprosessin virittämiseen - esim. Oppimisnopeus, kerrosten lukumäärä, neuronit jne. Yleensä meillä on alle sata hyperparametriä.