Sukeldume tugevdusõppesse. Selles artiklis käsitleme konkreetset probleemi tänapäevaste raamatukogudega nagu TensorFlow, TensorBoard, Keras ja OpenAI jõusaal. Näete, kuidas rakendada ühte põhilist algoritmi, mida nimetatakse sügavaks $ Q $ -lõppimiseks, et õppida selle sisemist toimimist. Mis puutub riistvarasse, siis töötab kogu kood tavalises arvutis ja kasutab kõiki leitud protsessori südamikke (TensorFlow haldab seda karbist välja).

Probleemi nimetatakse mägiautoks: auto on ühemõõtmelisel rajal, mis asub kahe mäe vahel. Eesmärk on sõita paremalt mäest üles (jõuda lipuni). Auto mootor ei ole siiski piisavalt tugev, et ühest sõidust mäele ronida. Seetõttu on ainus viis õnnestumiseks edasi-tagasi sõita, et hoogu juurde saada.

See probleem valiti seetõttu, et see on piisavalt lihtne, et leida protsessori tugevdamise õppega lahendus mõne minutiga ühest protsessori tuumast. See on aga piisavalt keeruline, et olla hea esindaja.

Esiteks annan lühikese kokkuvõtte sellest, mida tugevdav õppimine üldiselt teeb. Seejärel käsitleme põhitermineid ja väljendame nendega oma probleemi. Pärast seda kirjeldan sügavat $ Q $ -lõppimisalgoritmi ja rakendame selle probleemi lahendamiseks.

Tugevdamise õppimise põhitõed

Tugevdusõpe kõige lihtsamate sõnadega on katse-eksituse meetodil õppimine. Peategelast nimetatakse agendiks, mis oleks meie probleemis auto. Agent teeb keskkonnas toimingu ja talle antakse selle tegevuse eest uus tähelepanek ja tasu. Tugevdatakse suurematele hüvedele viivaid tegevusi, sellest ka nimi. Nagu paljude muude arvutiteaduste puhul, sai ka see inspiratsiooni elusolendite vaatlemisest.

Agendi koostoime keskkonnaga on kokku võetud järgmises graafikus:

meediumipäringu suurused tundliku disaini jaoks

Agent saab sooritatud toimingu eest vaatluse ja tasu. Seejärel teeb see uue toimingu ja astub teise sammu. Keskkond annab nüüd (tõenäoliselt) veidi teistsuguse tähelepaneku ja tasu. See jätkub, kuni terminali olek on saavutatud, millest saab märku agentile 'valmis' saatmisega. Kogu jada vaatlused> tegevused> järgmised vaatlused> hüved nimetatakse episoodiks (või trajektooriks).

Tulles tagasi meie Mäeauto juurde: meie auto on agent. Keskkond on ühemõõtmeliste mägede musta kasti maailm. Auto tegevus taandub ainult ühele numbrile: positiivse tulemuse korral lükkab mootor auto paremale. Kui see on negatiivne, lükkab see auto vasakule. Agent tajub vaatluse kaudu keskkonda: auto X-asendit ja -kiirust. Kui tahame, et meie auto sõidaks mäe otsas, määratleme tasu mugaval viisil: Agent saab -1 oma preemia iga sammu eest, kui ta pole eesmärki saavutanud. Eesmärgini jõudes episood lõpeb. Nii et tegelikult karistatakse agenti selle eest, et ta pole olukorras, kus me seda soovime. Mida kiiremini ta selleni jõuab, seda parem on talle. Agendi eesmärk on maksimeerida kogutasu, mis on ühe episoodi preemiate summa. Nii et kui see jõuab soovitud punkti näiteks 110 sammu järel, saab ta kokku -110 tulu, mis oleks Mountain Carile suurepärane tulemus, sest kui see eesmärki ei saavuta, siis karistatakse teda 200 sammu eest (seega tagasitulek -200).

See on kogu probleemi sõnastus. Nüüd saame selle anda algoritmidele, mis on juba piisavalt võimsad, et sellised probleemid mõne minutiga lahendada (kui need on hästi häälestatud). Väärib märkimist, et me ei ütle agendile, kuidas eesmärki saavutada. Me ei anna isegi vihjeid (heuristika). Agent leiab viisi (poliitika) ise võitmiseks.

Keskkonna seadistamine

Kõigepealt kopeerige kogu juhendaja kood kettale:

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

Nüüd peame installima Pythoni paketid, mida me kasutame. Et neid oma kasutajaruumi mitte installida (ja kokkupõrkeoht), muudame selle puhtaks ja installime need kondakeskkonda. Kui teil pole konda installitud, järgige palun https://conda.io/docs/user-guide/install/index.html .

Meie kondakeskkonna loomiseks toimige järgmiselt.

conda create -n tutorial python=3.6.5 -y

Selle aktiveerimiseks toimige järgmiselt.

source activate tutorial

Peaksite nägema (tutorial) ümbrises oleva viiba lähedal. See tähendab, et kondakeskkond nimega “õpetus” on aktiivne. Nüüdsest tuleks kõik käsud täita selles kondakeskkonnas.

Nüüd saame kõik sõltuvused installida oma hermeetilisse kondakeskkonda:

pip install -r requirements.txt

Installimisega oleme valmis, nii et käivitame mõne koodi. Me ei pea ise mägiauto keskkonda juurutama; selle rakenduse pakub OpenAI võimla raamatukogu. Vaatame oma keskkonnas juhuslikku agenti (juhuslikke toiminguid tegev agent):

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()

See on see.py fail; selle käivitamiseks käivitage:

python see.py

Peaksite nägema, kuidas auto läheb juhuslikult edasi-tagasi. Iga osa koosneb 200 etapist; kogutootlus on -200.

Nüüd peame juhuslikud tegevused asendama millegi paremaga. Algoritme, mida saaks kasutada, on palju. Sissejuhatava õpetuse jaoks sobib minu arvates lähenemine, mida nimetatakse sügavaks $ Q $ -lõppeks. Selle meetodi mõistmine annab kindla aluse teiste lähenemisviiside õppimiseks.

kuidas kasutada alglaadimismalli

Sügav $ Q $ -lõppimine

Algoritmi, mida kasutame, kirjeldasid esmakordselt 2013. aastal Mnih jt. aastal Atari mängimine sügava tugevdamise õppimisega ja poleeritud kaks aastat hiljem aastal Inimtasandi kontroll sügava tugevdava õppimise kaudu . Nendele tulemustele tuginevad paljud muud tööd, sealhulgas praegune tipptasemel algoritm Vikerkaar (2017):

Vikerkaar saavutab paljudes Atari 2600 mängudes üliinimliku jõudluse. Keskendume DQN-i põhiversioonile võimalikult väikeste hulga täiendavate täiendustega, et hoida seda õpetust mõistliku suurusega.

Reeglid, mida tavaliselt tähistatakse $ π (s) $, on funktsioon, mis tagastab antud olekus $ s $ üksikute toimingute tegemise tõenäosuse. Nii saab näiteks juhusliku mägiauto poliitika tagasi iga osariigi jaoks: 50% vasakule, 50% paremale. Mängu ajal võtame reaalsete toimingute saamiseks selle poliitika (levitamise) valimi.

$ Q $ -lõpe (Q on kvaliteedi jaoks) viitab funktsiooni väärtus-väärtus väärtusele $ Q_π (s, a) $. See tagastab antud osariigi $ s $ kogutootluse, valides toimingu $ a $, järgides konkreetset poliitikat $ π $. Kogutootlus on kõigi episoodide (trajektoori) preemiate summa.

Kui me teaksime optimaalset funktsiooni $ Q $, mida tähistatakse $ Q ^ * $, saaksime mängu hõlpsasti lahendada. Jälgime lihtsalt toiminguid, mille väärtus on $ Q ^ * $, st kõrgeim oodatav tootlus. See tagab, et jõuame kõrgeima võimaliku tootluseni.

Kuid me ei tea sageli dollarit $ Q ^ * $. Sellistel juhtudel saame selle keskkonnaga suhtlemisest lähendada - või „õppida“ -. See on nime „$ Q $ -lõppimine” osa. Selles on ka sõna 'sügav', kuna selle funktsiooni lähendamiseks kasutame sügavaid närvivõrke, mis on universaalsed funktsioonide lähendajad. Sügavad närvivõrgud, mis on ligikaudsed $ Q $ väärtustega, said nimeks Deep Q-Networks (DQN). Lihtsates keskkondades (kus mälus olevate olekute arv sobib) funktsiooni $ Q $ tähistamiseks võiks närvivõrgu asemel lihtsalt kasutada tabelit, mille nimi oleks näiteks 'tabelarvuline $ Q $ -õppimine'.

Seega on meie eesmärk nüüd funktsiooni $ Q ^ * $ ligikaudne väärtus. Kasutame Bellmani võrrandit:

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

$ s ’$ on osariigi $ s $ järel. $ γ $ (gamma), tavaliselt 0,99, on allahindlustegur (see on hüperparameeter). See paneb tulevastele hüvedele väiksema kaalu (kuna need on vähem kindlad kui kohesed hüved meie ebatäiusliku $ Q $ korral). Bellmani võrrand on $ Q $ -lõppimise jaoks keskne. Selles öeldakse, et $ Q $ väärtus antud riigi ja tegevuse jaoks on preemia $ r $, mis saadi pärast toimingu $ a $ kasutamist rohkem kõrgeim $ Q $ väärtus selle osariigi jaoks, kuhu me $ s ’$ maandume. Suurim on mõnes mõttes see, et valime toimingu $ a ’$, mis viib $ s’ $ suurima kogutootluseni.

Bellmani võrrandiga saame kasutada Q Q * * $ lähendamiseks juhendatud õppimist. Funktsiooni $ Q $ esitatakse (parameetritakse) närvivõrgu kaaludega, mida tähistatakse kui $ θ $ (teeta). Lihtsa rakendamise jaoks oleks võrgu sisendiks ja Q-väärtuse väljastamiseks olek ja toiming. Ebaefektiivsus seisneb selles, et kui me tahame teada kõigi Q-väärtuste väärtusi antud olekus, peame kutsuma $ Q $ nii palju kordi kui on toiminguid. On palju parem viis: võtta kõigi võimalike toimingute jaoks sisendiks ja väljundiks ainult $ Q $ -väärtused. Tänu sellele saame kõigi toimingute jaoks $ Q $ väärtused ühe eduseisuga.

Alustame juhuslike kaaludega võrgu $ Q $ treenimist. Keskkonnast saame palju üleminekuid (või “kogemusi”). Need on hulga (osariik, tegevus, järgmine osariik, tasu) või lühidalt ($ s $, $ a $, $ s ’$, $ r $). Me salvestame neid tuhandeid rõngapuhvrisse, mida nimetatakse 'kogemuste korduseks'. Seejärel valime selle puhvri kogemused sooviga, et Bellmani võrrand nende jaoks kehtiks. Me oleksime võinud puhvri vahele jätta ja kogemusi ükshaaval rakendada (seda nimetatakse „võrgus” või „poliitika”); probleem on selles, et järgnevad kogemused on omavahel tihedalt seotud ja DQN treenib selle tekkimisel halvasti. Sellepärast kasutati andmete korrelatsiooni purustamiseks kogemuste kordust (nn võrguühenduseta, poliitikaväline lähenemine). Meie kõige lihtsama ringpuhvri juurutamise koodi leiate kataloogist replay_buffer.py faili, soovitan teil seda lugeda.

Alguses, kuna meie närvivõrgu kaalud olid juhuslikud, jääb Bellmani võrrandi vasakpoolne väärtus parempoolsest kaugele. Ruudu erinevus on meie kaotuse funktsioon. Minimeerime kadumisfunktsiooni, muutes närvivõrgu kaalu $ θ $. Paneme kirja oma kaotuse funktsiooni:

[L (θ) = [Q (s, a) - r - γ tühik textrm {max} _ {a '} Q (s', a ')] ^ 2 ]

See on Bellmani ümber kirjutatud võrrand. Oletame, et valisime Mountain Car kogemuste kordusmängust kogemuse ($ s $, vasakul, $ s ’$, -1). Edastame oma $ Q $ võrgu edasi osariigiga $ s $ ja lahkumiseks annab see näiteks -120. Niisiis, $ Q (s, textrm {vasakul}) = -120 $. Seejärel söödame võrgu $ s ’$, mis annab näiteks -130 vasakule ja -122 paremale. Seega on $ s ’$ jaoks parim toiming õige, seega $ textrm {max} _ {a’} Q (s ’, a’) = -122 $. Me teame $ r $, see on tegelik tasu, mis oli -1. Seega oli meie $ Q $ -võrgu ennustus veidi vale, sest $ L (θ) = [-120 - 1 + 0,99 ⋅ 122] ^ 2 = (-0,22 ^ 2) = 0,0484 $. Seega levitame viga tagasi ja parandame kaalu $ $ $ veidi. Kui peaksime sama kogemuse jaoks uuesti kahju arvutama, oleks see nüüd väiksem.

Üks oluline tähelepanek enne, kui hakkame kodeerima. Pange tähele, et oma DQN-i värskendamiseks teeme DQN-il kaks edasipääsu ... ise. See viib sageli ebastabiilse õppimiseni. Selle leevendamiseks ei kasuta me järgmise osariigi $ Q $ prognoosi jaoks sama DQN-i. Kasutame selle vanemat versiooni, mida koodis nimetatakse target_model (selle asemel, et model olla peamine DQN). Tänu sellele on meil stabiilne sihtmärk. Värskendame target_model seades selle väärtusele model kaalud iga 1000 sammu järel. Kuid model värskendab igal sammul.

Vaatame koodi, mis loob DQN-mudeli:

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

Esiteks võtab funktsioon antud OpenAI võimla keskkonnast tegevuse ja vaatlusruumi mõõtmed. On vaja näiteks teada, kui palju väljundeid meie võrgul on. See peab olema võrdne toimingute arvuga. Toimingud on üks kuum kodeering:

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

Nii (nt) vasakule jääb [1, 0] ja paremale [0, 1].

Näeme, et vaatlused edastatakse sisendina. Möödume ka action_mask teise sisendina. Miks? $ Q (s, a) $ arvutamisel peame teadma $ Q $ väärtust ainult ühe antud toimingu jaoks, mitte kõigi nende jaoks. action_mask sisaldab 1 toimingute jaoks, mida soovime edastada DQN-i väljundisse. Kui action_mask on mõne toimingu jaoks 0, siis nullitakse vastav $ Q $ -väärtus väljundis. filtered_output kiht seda teeb. Kui tahame kõiki $ Q $ -väärtusi (max arvutamiseks), võime need kõik lihtsalt läbida.

Kood kasutab keras.layers.Dense täielikult ühendatud kihi määratlemiseks. Keras on Pythoni teek kõrgema taseme abstraktsiooniks TensorFlow peal. Kapoti all loob Keras graafiku TensorFlow, millel on eelarvamused, korralik kaalu initsialiseerimine ja muud madala tasemega asjad. Graafi määratlemiseks oleksime võinud kasutada lihtsalt töötlemata TensorFlow'i, kuid see ei ole üherealine.

Nii edastatakse vaatlused esimesele varjatud kihile, aktiveerides ReLU (alandatud lineaarne ühik). ReLU(x) on lihtsalt funktsioon $ textrm {max} (0, x) $. See kiht on täielikult ühendatud teise identse kihiga hidden_2 Väljundkiht vähendab neuronite arvu toimingute arvuni. Lõpuks on meil filtered_output, mis korrutab väljundi lihtsalt action_mask -ga.

Kaalude $ θ $ leidmiseks kasutame optimeerijat nimega “Adam” keskmise vea kadumisega ruudus.

Mudeli olemasolul saame seda kasutada $ Q $ väärtuste ennustamiseks antud oleku vaatluste korral:

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

Soovime kõigi toimingute jaoks $ Q $ väärtusi, seega action_mask on nende vektor.

Tegeliku koolituse tegemiseks kasutame fit_batch()

edukaim tutvumissait 2016

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]

Partii sisaldab BATCH_SIZE kogemusi. next_q_values on $ Q (s, a) $. q_values on Bellmani võrrandist $ r + γ space textrm {max} _ {a ’} Q (s’, a ’) $. Meie tehtud toimingud on üks kuumkodeeritud ja läbitud kui action_mask sisendile helistades model.fit(). $ y $ on juhendatud õppes tavaline täht sihtmärgi jaoks. Siin möödume q_values. Ma teen q_values[:. None] massiivi mõõtme suurendamiseks, kuna see peab vastama one_hot_actions mõõtmele massiiv. Seda nimetatakse viilu märkimiseks, kui soovite selle kohta rohkem lugeda.

Tagastame kaotuse, et see salvestada TensorBoardi logifaili ja hiljem visualiseerida. Jälgime veel paljusid asju: mitu sammu sekundis teeme, kogu RAM-i kasutus, milline on episoodide keskmine tulu jne. Vaatame neid jooniseid.

Jooksmine

TensorBoardi logifaili visualiseerimiseks peame kõigepealt selle omama. Tehkem siis lihtsalt koolitus:

python run.py

See prindib kõigepealt meie mudeli kokkuvõtte. Seejärel loob see praeguse kuupäevaga logikataloogi ja alustab koolitust. Iga 2000 sammu järel trükitakse logiliin sarnaselt sellele:

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

Iga 20 000 korral hindame oma mudelit 10 000 sammuga:

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

Pärast 677 jagu ja 120 000 sammu paranes keskmine episoodide tagasitulek vahemikus -200 kuni -136,75! See on kindlasti õppimine. Mis avg_max_q_value kas jätan lugejale hea harjutuse. Kuid see on treeningu ajal väga kasulik statistika.

Pärast 200 000 sammu on meie koolitus tehtud. Minu neljatuumalises protsessoris võtab see aega umbes 20 minutit. Saame vaadata date-log kataloog, nt 06-07-18-39-log. .h5 -Ga on neli mudelifaili pikendamine. See on hetktõmmis TensorFlow graafikute kaaludest, salvestame need iga 50 000 sammu järel, et hiljem tutvuda õpitud poliitikaga. Selle vaatamiseks toimige järgmiselt.

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

Teiste võimalike lippude nägemiseks: python run.py --help.

Nüüd teeb auto soovitud eesmärgi saavutamiseks palju paremat tööd. Väljal date-log kataloogis on ka events.out.* faili. See on fail, kuhu TensorBoard oma andmeid salvestab. Kirjutame sellele, kasutades lihtsamat TensorBoardLogger määratletud loggers.py. Sündmuste faili vaatamiseks peame käivitama kohaliku TensorBoardi serveri:

tensorboard --logdir=.

--logdir osutab lihtsalt kataloogile, kus on kuupäevalogi katalooge, meie juhul on see praegune kataloog, seega .. TensorBoard prindib URL-i, mida see kuulab. Kui avad http://127.0.0.1:6006 , peaksite nägema kaheksa sarnast maatükki:

Pakkimine

train() teeb kogu koolituse. Kõigepealt loome mudeli ja mängime puhvri uuesti. Seejärel suhtleme see.py omaga väga sarnases ringis keskkonnaga ja salvestame kogemused puhvrisse. Oluline on see, et järgiksime epsiloni ahne poliitikat. Saime alati valida parima toimingu vastavalt funktsioonile $ Q $; see aga pärsib uurimist, mis kahjustab üldist jõudlust. Nii et uurimise sundimiseks epsiloni tõenäosusega teostame juhuslikke toiminguid:

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()

Epsiloni väärtuseks määrati 1%. Pärast 2000 kogemust täitub kordus koolituse alustamiseks piisavalt. Teeme seda helistades fit_batch() juhusliku partii kogemustega, mis on võetud korduspuhvrist:

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

Iga 20 000 sammu järel hindame ja logime tulemusi (hindamine toimub epsilon = 0, täiesti ahne poliitika järgi):

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)

Kogu kood on umbes 300 rida ja run.py sisaldab umbes 250 kõige olulisemat.

Võib märgata, et hüperparameetreid on palju:

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

Ja see pole isegi kõik neist. Samuti on olemas võrguarhitektuur - kasutasime kahte varjatud kihti 32 neuroniga, ReLU aktiveerimist ja Adami optimeerijat, kuid on ka palju muid võimalusi. Isegi väikestel muudatustel võib olla koolitusele tohutu mõju. Hüperparameetrite häälestamiseks võib kulutada palju aega. Hiljutisel OpenAI võistlusel teise koha võistleja sain teada on võimalik peaaegu topelt Vikerkaare skoor pärast hüperparameetri häälestamist. Loomulikult tuleb meeles pidada, et seda on lihtne üle paigaldada. Praegu on tugevdamisalgoritmid hädas teadmiste ülekandmisega sarnastesse keskkondadesse. Meie mägiauto ei laiene praegu igat tüüpi mägedele. Saate tegelikult muuta OpenAI võimla keskkonda ja vaadata, kui kaugele agent saab üldistada.

Teine harjutus on leida minu omast parem hüperparameetrite komplekt. See on kindlasti võimalik. Ühest treeningjooksust ei piisa, et hinnata, kas teie muudatus on paranemine. Treeningjooksudel on tavaliselt suur erinevus; dispersioon on suur. Teil oleks vaja palju jooksu, et teha kindlaks, et midagi on parem. Kui soovite rohkem lugeda sellisest olulisest teemast nagu reprodutseeritavus, soovitan teil lugeda Sügav tugevdamine, mis loeb . Käsitsi häälestamise asemel saame seda protsessi mingil määral automatiseerida - kui oleme valmis kulutama probleemile rohkem arvutusvõimsust. Lihtne lähenemisviis on koostada mõne hüperparameetri jaoks paljutõotav väärtuste vahemik ja seejärel käivitada ruudustikuotsing (kontrollides nende kombinatsioone), paralleelselt toimuvate koolitustega. Paralleelsus on iseenesest suur teema, kuna see on suure jõudluse jaoks ülioluline.

Sügav $ Q $ -lõpe esindab suurt tugevdavate õppimisalgoritmide perekonda, mis kasutavad väärtuste iteratsiooni. Püüdsime funktsiooni $ Q $ ligikaudseks muuta ja kasutasime seda enamasti ahnelt. On veel üks perekond, kes kasutab poliitika kordamist. Nad ei keskendu funktsiooni $ Q $ lähendamisele, vaid otsivad optimaalse poliitika $ π ^ * $. Selleks, et näha, kuhu väärtus iteratsioon sobib tugevdava õppimise algoritmide maastikku:

Teie mõtted võivad olla sellised, et sügav tugevdamine õppimine tundub habras. Teil on õigus; probleeme on palju. Võite viidata Sügava tugevdamise õppimine ei toimi veel ja Tugevdusõpe ei töötanud kunagi ja „sügav“ aitas ainult natuke .

See lõpetab õpetuse. Rakendasime õppimiseks oma põhilise DQN-i. Väga sarnane kood saab kasutada mõnel Atari mängul hea tulemuse saavutamiseks. Praktilistes rakendustes võetakse sageli testitud, suure jõudlusega rakendusi, näiteks üks OpenAI lähtejooned . Kui soovite näha, milliste väljakutsetega võib silmitsi seista, kui proovite rakendada sügavat tugevdavat õppimist keerukamas keskkonnas, võite lugeda Meie NIPS 2017: lähenemisviisi õppimine . Kui soovite lõbusas võistluskeskkonnas rohkem teada saada, vaadake seda NIPS 2018 võistlused või crowai.org .

Kui olete teel a masinõpe asjatundja ja sooviksite oma teadmisi juhendatava õppimise alal süvendada Masinõppiv videoanalüüs: kalade tuvastamine lõbusaks katseks kalade tuvastamiseks.

Seotud: Flappy Birdi koolitamine: tugevdamise õppematerjal

Põhitõdede mõistmine

Mis on tugevdamine õppimine?

Tugevdusõpe on bioloogiliselt inspireeritud katse-eksituse meetod agendi koolitamiseks. Premeerime agenti heade tegude eest soovitud käitumise tugevdamiseks. Karistasime ka valesid tegevusi, nii et neid juhtuks harvemini.

Mis on Q Q-õppes?

Q tähistab kvaliteeti. See viitab tegevuse väärtuse funktsioonile, mida tähistatakse Qπ (s, a). See tagastab antud riigi s kogutootluse, valides tegevuse a, järgides konkreetset poliitikat π. Kogutootlus on kõigi episoodide preemiate summa.

Mis on Bellmani võrrand?

Q (s, a) = r + y maxa'Q (s ', a'). Suuliselt: Q-väärtus antud olekus ja tegevuses on preemia r, mis saadakse pärast tegutsemist a + kõrgeim Q-väärtus selle riigi jaoks, kuhu me s asume. Mõnes mõttes suurim, et me valime tegevuse a, mis viib s-i suurima kogutootluseni.

Mis on Bellmani optimaalsuse põhimõte?

Optimaalsuse põhimõte: optimaalsel poliitikal on omadus, et olenemata algseisundist ja toimingutest peavad ülejäänud tegevused moodustama optimaalse poliitika esialgsest tegevusest tuleneva seisundi suhtes. Seda kasutatakse Q-õppes, kuid üldiselt igas dünaamilises programmeerimistehnikas.

.net veebiapi õpetus

Mis on parameetrid ja hüperparameetrid?

Parameetrid viitavad mudeli parameetritele, nii et närvivõrkude kasutamisel viitab see nende kaalule. Tavaliselt on meil tuhandeid või miljoneid parameetreid. Hüperparameetreid kasutatakse õppeprotsessi häälestamiseks - nt õppimiskiirus, kihtide arv, neuronid jne. Tavaliselt on meil hüperparameetreid vähem kui sada.