K-õppimine: kõik, mida peate teadma tugevdamise õppimise kohta

ja on mõned domeenid, mis kuuluvad selle valdkonna populaarseimate moesõnade hulka ja mõjuval põhjusel. Tehisintellekt loob 2020. aastaks 2,3 miljonit töökohta, arvestades, et selle peamine eesmärk on võimaldada masinatel jäljendada inimeste käitumist. Veider, kas pole? Niisiis, täna arutleme Q-õppe, tugevdamise õppimise ehitusmaterjali üle, järgmises järjekorras:

• Mis on tugevdamine õppimine?
• Q-õppeprotsess
• Bellmani võrrand
• Markovi otsustusprotsess
• Q-õppe demo: NumPy

Mis on tugevdamine õppimine?

Heidame pilgu oma igapäevaellu. Me täidame arvukalt ülesandeid keskkonnas ja mõned neist ülesannetest toovad meile kasu, mõned aga mitte. Otsime pidevalt erinevaid teid ja püüame välja selgitada, milline tee toob kasu ja parandame oma tegevuse põhjal strateegiaid eesmärkide saavutamiseks. See on mu sõbrad on tugevdamise õppimise üks lihtsamaid analoogiaid.

Peamised huvialad:

• Keskkond
• Tegevus
• Auhind
• Osariik

Tugevdusõpe on masinõppe haru, mis võimaldab süsteemidel õppida oma otsuste tulemustest. See lahendab teatud tüüpi probleemi, kus otsuste tegemine on järjestikune ja eesmärk on pikaajaline.

Q-õppeprotsess

Mõistame, mis on Q-õppimine, meie probleemipüstitusega siin. See aitab meil määratleda tugevdava õppelahenduse põhikomponendid, st agendid, keskkond, tegevused, hüved ja olekud.

Autotehase analoogia:

Oleme robotite täis autotehases. Need robotid aitavad tehase töötajaid, edastades auto kokkupanekuks vajalikke osi. Need erinevad osad asuvad tehase erinevates kohtades 9 jaamas. Osade hulka kuuluvad šassii, rattad, armatuurlaud, mootor ja nii edasi. Factory Master on prioriteetseks seadnud šassii paigaldamise koha. Vaatame seadistust siin:

Osariigid:

Asukohta, kus robot konkreetses eksemplaris viibib, nimetatakse selle olekuks. Kuna seda on lihtne kodeerida, mitte nimede järgi meelde jätta. Kaardistame asukoha numbritega.

Toimingud:

mis on Java-s anonüümne klass

Toimingud pole muud kui robotite käigud mis tahes asukohta. Mõelgem, robot asub L2 asukohas ja otsesed asukohad, kuhu ta saab liikuda, on L5, L1 ja L3. Saame sellest paremini aru, kui me seda visualiseerime:

Preemiad:

Robotile antakse preemia otse ühest olekust teise liikumise eest. Näiteks jõuate L5-le otse L2-st ja vastupidi. Mõlemal juhul antakse preemia 1. Vaatame preemia tabelit:

Pidage meeles, kui tehase kapten määras šassii asukoha prioriteediks. See oli L7, nii et lisame selle fakti oma hüvede tabelisse. Seega määrame asukohas (L7, L7) väga suure arvu (meie puhul 999).

Bellmani võrrand

Oletame, et robot peab liikuma punktist A punkti B. See valib tee, mis annab positiivse tasu. Oletame, et pakume selle jälgimiseks tasu jalajäljena.

Aga mis siis, kui robot alustab kusagilt vahepealsest kohast, kus ta näeb kahte või enamat rada. Seega ei saa robot otsust vastu võtta ja see juhtub peamiselt seetõttu, et tal pole a mälu . Siin tuleb pildile Bellmani võrrand.

V (s) = max (R (s, a) + & # 120632V (s))

Kus:

• s = konkreetne seisund
• a = tegevus
• s '= olek, kuhu robot läheb s-st
• & # 120632 = allahindlustegur
• R (s, a) = preemiafunktsioon, mis võtab oleku (d) ja toimingu (a) ning väljastab preemia väärtuse
• V (s) = kindlas seisundis viibimise väärtus

Nüüd on sihtkoha all oleval plokil preemia 1, mis on kõrgeim preemia, aga kuidas on lood teise plokiga? Noh, siin tuleb allahindlustegur. Oletame, et allahindlustegur on 0,9 ja täidame kõik plokid ükshaaval.

Markovi otsustusprotsess

Kujutage ette, et robot asub oranžis plokis ja peab sihtkohta jõudma. Kuid isegi väikese düsfunktsiooni korral on robot segaduses, millist teed mööda minna, selle asemel et minna üles.

Seega peame otsustamisprotsessi muutma. Peab Osaliselt juhuslik ja Osaliselt roboti kontrolli all . Osaliselt juhuslik, kuna me ei tea, millal robot talitlushäire on ja osaliselt kontrolli all, sest see on ikkagi roboti otsus. Ja see on Markovi otsustusprotsessi alus.

Markovi otsustusprotsess (MDP) on diskreetne ajastohhastiline juhtimisprotsess. See annab matemaatilise raamistiku otsuste langetamiseks olukordades, kus tulemused on osaliselt juhuslikud ja osaliselt otsustaja kontrolli all.

Nii et kasutame oma algset Bellmani võrrandit ja teeme selles muudatusi. Mida me ei tea, on järgmine osariik st. s ’. Mida me teame, on kõik pöörde võimalused ja muutkem võrrandit.

V (s) = max (R (s, a) + & # 120632 V (s))

V (s) = max (R (s, a) + & # 120632) & Sigma_{s ’}P (s, a, s ’) V (s))

P (s, a, s ’): Riigist liikumise tõenäosus s kuni s ’ tegevusega kuni

& Sigma_{s ’}P (s, a, s ’) V (s): Roboti juhuslikkuse ootused

V (s) = max (R (s, a) + & # 120632 ((0,8 V (ruum_üles)) + (0,1 V (ruum_alla) +….))

Nüüd läheme üle Q-õppesse. Q-õppimine kujutab endast mõtet hinnata seisundisse siirdumiseks võetava tegevuse kvaliteeti, mitte määrata selle riigi võimalikku väärtust, kuhu ta liigub.

luua massiivi objekte java

See on see, mida saame, kui kaasame idee hinnata teatud riiki siirdumise meetmete kvaliteeti. Kui eemaldame need uuendatud Bellmani võrrandist max komponent, eeldame võimaliku tegevuse jaoks ainult ühte jalajälge, mis pole midagi muud kui Kvaliteet hagi.

Q (s, a) = (R (s, a) + ja # 120632) & Sigma_{s ’}P (s, a, s ’) V (s))

Selles võrrandis, mis kvantifitseerib tegevuse kvaliteeti, võime eeldada, et V (s) on Q (s, a) kõigi võimalike väärtuste maksimum. Seega asendame v (s ’) funktsiooniga Q ().

Q (s, a) = (R (s, a) + ja # 120632) & Sigma_{s ’}P (s, a, s ’) max Q (s ’, a’))

Oleme vaid ühe sammu lähedal oma Q-õppe lõplikule võrrandile. Tutvustame a Ajaline erinevus Q-väärtuste arvutamiseks keskkonna muutuste suhtes ajas. Kuidas aga jälgida Q muutumist?

TD (s, a) = (R (s, a) + & # 120632) & Sigma_{s ’}P (s, a, s ’) max Q (s ’, a’)) - Q (s, a)

Arvutame uue Q (s, a) sama valemiga ümber ja lahutame sellest varem teadaolevad Q (s, a). Niisiis saab ülaltoodud võrrand:

Q_t(s, a) = Q_t-1(s, a) + a TD_ts, a)

Q_t(s, a) = Praegune Q-väärtus

Q_t-1(s, a) = Eelmine Q-väärtus

Q_t(s, a) = Q_t-1(s, a) + α (R (s, a) + & # 120632 max Q (s ’, a’)_-Q_t-1s, a)

mis on protseduur ruutmeetrites

Q õppe demo: NumPy

Kavatsen kasutada NumPy, et näidata, kuidas Q-õppimine töötab.

1. samm: import, parameetrid, olekud, toimingud ja preemiad

impordi number np gamma = 0,75 # Soodustegur alfa = 0,9 # Õppimismäära location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} toimingud = [0,1,2,3,4,5,6,7,8] hüved = np.array ( [[0,1,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0], [0,1,0,0, 0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,1,0] , [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,1,0], [0,0,0,0, 1,0,1,0,1], [0,0,0,0,0,0,0,1,0]])

2. samm: kaardistage asukohtade indeksid

state_to_location = asukoha diktsioon ((osariik, asukoht), olek asukohas_to_state.items ())

3. samm: saate Q-õppeprotsessi abil optimaalse marsruudi

def get_optimal_route (algusasukoht, lõppkoht): hüved_uudis = np.koopia (hüved) lõpupunkt = asukoht_koht_koht [lõpp-asukoht] hüved_uudised [lõpupeatus, lõppjaam] = 999 Q = np.array (np.zeros ([9,9])) # Q Õppimisprotsess vahemikus (1000) olevale i-le: # juhusliku oleku võtmine current_state = np.random.randint (0,9) # Python välistab ülemise piiri mängitavad toimingud = [] # i iteratsioon läbi vahemikus j oleva uue hüvede maatriksi ( 9): if rewards_new [current_state, j]> 0: playable_actions.append (j) # Valige juhuslik toiming, mis viib meid järgmisesse olekusse next_state = np.random.choice (playable_actions) # Ajalise erinevuse arvutamine TD = rewards_new [current_state , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # Q-väärtuse värskendamine Bellmani võrrandi Q [current_state, next_state] + = alfa * TD # abil Alustage optimaalne marsruut lähtekoha marsruudiga = [start_location] #Inicialiseeri järgmine_location lähtekohaga next_location = tärn t_location # Me ei tea lõpliku asukoha saavutamiseks vajalike täpsete iteratsioonide arvu, seega on silmus hea kordamiseks samal ajal (next_location! = end_location): # Too lähteseisund start_state = location_to_state [start_location] # Tõmmake kõrgeim algväärtusega seotud Q-väärtus next_state = np.argmax (Q [lähteandmik,]) # Saime järgmise oleku indeksi. Kuid meil on vaja vastavat kirja. next_location = state_to_location [next_state] route.append (next_location) # Uuendage järgmise iteratsiooni alguskohta start_location = next_location tagasitee

4. samm: printige marsruut

print (get_optimal_route ('L1', 'L9'))

Väljund:

Sellega oleme jõudnud Q-õppe lõppu. Loodan, et õppisite tundma Q-õppe tööd koos mitmesuguste sõltuvustega, nagu näiteks ajaline erinevus, Bellmani võrrand ja palju muud.

Edureka oma paneb sind tundma selliseid tehnikaid nagu juhendatud õppimine, järelevalveta õppimine ja loomuliku keele töötlemine. See hõlmab koolitust tehisintellekti ja masinõppe uusimate edusammude ja tehniliste lähenemisviiside kohta, nagu sügavõpe, graafilised mudelid ja tugevdav õppimine.