By Pau Labarta Bajo, matematiker og dataforsker.

Venezias drosjer forbi Helena Jankovičová Kováčová fra Pexels.

Dette er del 2 av mitt praktiske kurs om forsterkende læring, som tar deg fra null til HERO. I dag skal vi lære om Q-learning, en klassisk RL-algoritme født på 90-tallet.

Hvis du savnet del 1, les den for å få sjargongen og det grunnleggende på plass for forsterkende læring.

I dag løser vi vårt første læringsproblem...

Vi skal lære opp en agent til å kjøre taxi!

Vel, en forenklet versjon av et taximiljø, men en taxi på slutten av dagen.

Vi skal bruke Q-learning, en av de tidligste og mest brukte RL-algoritmene.

Og selvfølgelig Python.

All koden for denne leksjonen er inne denne Github-repoen. Git klone den for å følge med på dagens problem.

1. Taxikjøringsproblemet

Vi vil lære en agent å kjøre taxi ved hjelp av forsterkningslæring.

Å kjøre taxi i den virkelige verden er en veldig kompleks oppgave å begynne med. På grunn av dette vil vi jobbe i et forenklet miljø som fanger opp de 3 essensielle tingene en god drosjesjåfør gjør, som er:

• plukke opp passasjerer og slippe dem til ønsket destinasjon.
• kjør trygt, noe som betyr at ingen krasj.
• kjøre dem på kortest mulig tid.

Vi vil bruke et miljø fra OpenAI Gym, kalt Taxi-v3 miljø.

Det er fire utpekte steder i rutenettverdenen indikert med R(ed), G(reen), Y(ellow) og B(lue).

Når episoden starter, starter taxien ved et tilfeldig firkant, og passasjeren er på et tilfeldig sted (R, G, Y eller B).

Taxien kjører til passasjerens plassering, henter passasjeren, kjører til passasjerens destinasjon (en annen av de fire angitte stedene), og slipper deretter av passasjeren. Mens vi gjør det, må taxisjåføren vår kjøre forsiktig for å unngå å treffe en vegg, merket som |. Når passasjeren er sluppet av, avsluttes episoden.

Slik driver q-learning-agenten vi skal bygge i dag:

Før vi kommer dit, la oss forstå godt hva som er handlingene, tilstandene og belønningene for dette miljøet.

2. Miljø, handlinger, stater, belønninger

notatbøker/00_environment.ipynb

La oss først laste miljøet:

Hva er handlinger agenten kan velge mellom på hvert trinn?

• 0 kjør ned
• 1 kjøring opp
• 2 kjør til høyre
• 3 kjøring igjen
• 4 hent en passasjer
• 5 slipp av en passasjer

Og stater?

• 25 mulige taxiposisjoner fordi verden er et 5×5 rutenett.
• 5 mulige plasseringer av passasjeren, som er R, G, Y, B, pluss tilfellet når passasjeren er i taxien.
• 4 destinasjonssteder

som gir oss 25 x 5 x 4 = 500 tilstander.

Hva med belønninger?

• -1 standard belønning per trinn.
  Hvorfor -1, og ikke bare 0? Fordi vi ønsker å oppmuntre agenten til å bruke kortest tid, ved å straffe hvert ekstra trinn. Dette er hva du forventer av en taxisjåfør, ikke sant?
• + 20 belønning for å levere passasjeren til riktig destinasjon.
• -10 belønning for å utføre en henting eller avlevering på feil sted.

Du kan lese belønningene og miljøovergangene (tilstand, handling ) → neste_tilstand fra env.P.

Forresten, du kan gjengi miljøet under hver tilstand for å dobbeltsjekke disse env.P-vektorene som er fornuftige:

Fra tilstand=123:

agenten flytter sørover action=0 for å komme til state=223:

Og belønningen er -1, da verken episoden ble avsluttet eller sjåføren valgte eller droppet feil.

3. Tilfeldig agent-grunnlinje

notebooks/01_random_agent_baseline.ipynb

Før du begynner å implementere en kompleks algoritme, bør du alltid bygge en grunnlinjemodell.

Dette rådet gjelder ikke bare for forsterkningslæringsproblemer, men maskinlæringsproblemer generelt.

Det er veldig fristende å hoppe rett inn i de komplekse/fancy algoritmene, men med mindre du er virkelig erfaren, vil du mislykkes fryktelig.

La oss bruke en tilfeldig agent som basismodell.

Vi kan se hvordan denne agenten fungerer for en gitt starttilstand=198:

3,804 XNUMX skritt er mye!

Se det selv i denne videoen:

For å få et mer representativt mål på ytelsen kan vi gjenta den samme evalueringssløyfen n=100 ganger med start hver gang i en tilfeldig tilstand.

Hvis du plotter tidstrinn_per_episode og straffer_per_episode du kan observere at ingen av dem reduseres ettersom agenten fullfører flere episoder. Med andre ord, agenten LÆRER IKKE noe.

Hvis du vil ha oppsummerende statistikk over ytelse, kan du ta gjennomsnitt:

Å implementere agenter som lærer er målet med forsterkende læring, og dette kurset også.

La oss implementere vår første "intelligente" agent ved å bruke Q-learning, en av de tidligste og mest brukte RL-algoritmene som finnes.

4. Q-læringsagent

notatbøker/02_q_agent.ipynb

Q-læring (Av Chris Walkins og Peter Dayan) er en algoritme for å finne den optimale q-verdifunksjonen.

Som vi sa i del 1, q-verdifunksjonen Q(er, a) knyttet til en policy π er den totale belønningen agenten forventer å få når han er i staten s agenten tar affære a og følger retningslinjer π deretter.

Den optimale q-verdifunksjonen Q*(s, a)er q-verdifunksjonen knyttet til den optimale policyen π*.

Hvis du vet Q*(s, a), du kan utlede π*: det vil si at du velger som neste handling den som maksimerer Q*(s, a) for gjeldende tilstand s.

Q-learning er en iterativ algoritme for å beregne bedre og bedre tilnærminger til den optimale q-verdifunksjonen Q*(s, a), med utgangspunkt i en vilkårlig innledende gjetning Q⁰(s, a).

I et tabellmiljø som Taxi-v3 med et begrenset antall tilstander og handlinger, er en q-funksjon i hovedsak en matrise. Den har like mange rader som tilstander og kolonner som handlinger, dvs. 500 x 6.

ok, men hvordan beregner du den neste tilnærmingen Q¹(s, a) fra Q⁰(s, a)?

Dette er nøkkelformelen i Q-learning:

Som vår q-agent navigerer miljøet og observerer neste tilstand s ' og belønning r, oppdaterer du q-verdimatrisen din med denne formelen.

Hva er læringsraten 𝛼 i denne formelen?

De læringsfrekvens (som vanlig i maskinlæring) er et lite tall som styrer hvor store oppdateringene til q-funksjonen er. Du må justere den, siden for stor verdi vil føre til ustabil trening, og for liten er kanskje ikke nok til å unnslippe lokale minima.

Og denne rabattfaktoren 𝛾?

De rabattfaktor er en (hyper) parameter mellom 0 og 1 som bestemmer hvor mye vår agent bryr seg om belønninger i en fjern fremtid i forhold til de i umiddelbar fremtid.

• Når 𝛾=0, bryr agenten seg kun om å maksimere umiddelbar belønning. Som det skjer i livet, er ikke maksimering av umiddelbar belønning den beste oppskriften på optimale langsiktige resultater. Dette skjer også i RL-agenter.
• Når 𝛾=1, evaluerer agenten hver av sine handlinger basert på summen av alle fremtidige belønninger. I dette tilfellet vekter agenten like umiddelbare belønninger og fremtidige belønninger.

Diskonteringsfaktoren er typisk en mellomverdi, f.eks. 0.6.

For å oppsummere, hvis du

• trene lenge nok
• med en grei læringsrate og rabattfaktor
• og agenten utforsker nok statens rom
• og du oppdaterer q-verdimatrisen med Q-læringsformelen,

din første tilnærming vil til slutt konvergere til optimal q-matrise. Voila!

La oss implementere en Python-klasse for en Q-agent da.

APIen er den samme som for RandomAgent ovenfor, men med en ekstra metode update_parameters(). Denne metoden tar overgangsvektoren (stat, handling, belønne, neste_stat) og oppdaterer q-verdimatrisetilnærmingen self.q_table ved å bruke Q-læringsformelen ovenfra.

Nå må vi koble denne agenten til en treningsløkke og kalle opp dens update_parameters() metode hver gang agenten samler inn en ny opplevelse.

Husk også at vi må garantere at agenten utforsker nok statens plass. Husk utforskning-utnyttelsesparameteren vi snakket om i del 1? Dette er når epsilon parameteren kommer inn i spillet.

La oss trene agenten til n_episodes = 10,000 og bruk epsilon = 10 %:

Og plott tidstrinn_per_episode og straffer_per_episode:

Hyggelig! Disse grafene ser mye bedre ut enn for RandomAgent. Begge beregningene reduseres med opplæring, noe som betyr at agenten vår lærer.

Vi kan faktisk se hvordan agenten kjører fra samme tilstand = 123 som vi brukte for RandomAgent.

Fin tur av vår Q-agent!

Hvis du vil sammenligne harde tall, kan du evaluere ytelsen til q-agenten på, la oss si, 100 tilfeldige episoder og beregne gjennomsnittlig antall tidsstempler og straffer som påløper.

Litt om epsilon-grådig politikk

Når du evaluerer agenten, er det fortsatt god praksis å bruke en positiv epsilon-verdi, og ikke epsilon = 0.

Whe så? Er ikke agenten vår fullt opplært? Hvorfor trenger vi å beholde denne kilden til tilfeldighet når vi velger neste handling?

Årsaken er å forhindre overtilpasning.

Selv for en så liten delstat, handlingsrom i Taxi-v3 (dvs. 500 x 6), er det sannsynlig at agenten vår under trening ikke har besøkt nok visse stater. Derfor er ytelsen i disse tilstandene kanskje ikke 100 % optimal, noe som får agenten til å bli "fanget" i en nesten uendelig løkke av suboptimale handlinger. Hvis epsilon er et lite positivt tall (f.eks. 5 %), kan vi hjelpe agenten med å unnslippe disse uendelige løkkene av suboptimale handlinger.

Ved å bruke en liten epsilon ved evaluering, tar vi i bruk en såkalt epsilon-grådig strategi.

La oss vurdere vår trente agent på n_episoder = 100 bruker epsilon = 0.05. Observer hvordan sløyfen ser ut nesten nøyaktig som togsløyfen ovenfor, men uten oppfordring til update_parameters():

Disse tallene ser mye bedre ut enn for RandomAgent.

Vi kan si at agenten vår har lært seg å kjøre taxi!

Q-learning gir oss en metode for å beregne optimale q-verdier. Men, hva med hyper-parametrene alfa, gamma og epsilon?

Jeg valgte dem for deg, ganske vilkårlig. Men i praksis må du stille dem inn for RL-problemene dine.

La oss utforske deres innvirkning på læring for å få en bedre intuisjon av hva som skjer.

5. Hyper-parameter tuning

notebooks/03_q_agent_hyperparameters_analysis.ipynb

La oss lære opp q-agenten vår ved å bruke forskjellige verdier for alfa (læringsfrekvens) og gamma (rabattfaktor). Når det gjelder epsilon, holder vi den på 10 %.

For å holde koden ren, kapslet jeg inn q-agent-definisjonen src/q_agent.py og treningsløkken inne i tog() fungere i src/loops.py.

La oss plotte tidstrinnene per episode for hver kombinasjon av hyperparametere.

Grafen ser kunstnerisk ut, men litt for støyende.

Noe du imidlertid kan observere er at når alfa = 0.01 er læringen tregere. alfa (læringshastighet) styrer hvor mye vi oppdaterer q-verdiene i hver iterasjon. For liten verdi innebærer tregere læring.

La oss forkaste alpha = 0.01 og gjøre 10 treningsøkter for hver kombinasjon av hyperparametere. Vi bruker gjennomsnittet av tidstrinnene for hvert episodenummer, fra 1 til 1000, ved å bruke disse 10 kjøringene.

Jeg har laget funksjonen train_many_runs() i src/loops.py for å holde den bærbare koden renere:

Det ser ut som alpha = 1.0 er verdien som fungerer best, mens gamma ser ut til å ha mindre innvirkning.

Gratulerer! Du har justert din første læringsrate i dette kurset.

Justering av hyperparametre kan være tidkrevende og kjedelig. Det er utmerkede biblioteker for å automatisere den manuelle prosessen vi nettopp fulgte, som Optuna, men dette er noe vi skal leke med senere i kurset. Nyt foreløpig farten i treningen vi nettopp har funnet.

Vent, hva skjer med denne epsilonen = 10 % som jeg ba deg stole på meg?

Er den nåværende 10 %-verdien den beste?

La oss sjekke det selv.

Vi tar det beste alfa og gamma vi fant, dvs.

• alfa = 1.0
• gamma = 0.9 (vi kunne ha tatt 0.1 eller 0.6 også)

Og tren med forskjellige epsiloner = [0.01, 0.1, 0.9]

Og plott de resulterende tidstrinnene og straffkurvene:

Som du kan se, ser det ut til at både epsilon = 0.01 og epsilon = 0.1 fungerer like bra, siden de har den rette balansen mellom leting og utnyttelse.

På den andre siden er epsilon = 0.9 for stor verdi, noe som forårsaker «for mye» tilfeldighet under trening og hindrer q-matrisen vår i å konvergere til den optimale. Observer hvordan ytelsen platåer ved rundt 250 tidstrinn per episode.

Generelt sett er den beste strategien for å velge epsilon hyper-parameter progressivt epsilon-forfall. Det vil si at i begynnelsen av treningen, når agenten er veldig usikker på sin q-verdi-estimering, er det best å besøke så mange stater som mulig, og for det er en stor epsilon bra (f.eks. 50 %)

Etter hvert som treningen skrider frem og agenten avgrenser sin q-verdi-estimering, er det ikke lenger optimalt å utforske så mye. I stedet kan agenten ved å redusere epsilon lære å perfeksjonere og finjustere q-verdiene for å få dem til å konvergere raskere til de optimale. For stor epsilon kan forårsake konvergensproblemer, som vi ser for epsilon = 0.9.

Vi skal tune epsiloner langs banen, så jeg vil ikke insistere for mye for øyeblikket. Igjen, nyt det vi har gjort i dag. Det er ganske bemerkelsesverdig.

B-R-A-V-O! (Bilde av forfatteren).

Oppsummering

Gratulerer med (sannsynligvis) løst ditt første Reinforcement Learning-problem.

Dette er de viktigste læringene jeg vil at du skal sove på:

• Vanskeligheten med et forsterkningslæringsproblem er direkte relatert til antall mulige handlinger og tilstander. Taxi-v3 er et tabellmiljø (dvs. et begrenset antall tilstander og handlinger), så det er enkelt.
• Q-learning er en læringsalgoritme som fungerer utmerket for tabellmiljøer.
• Uansett hvilken RL-algoritme du bruker, er det hyperparametre du må justere for å sikre at agenten din lærer den optimale strategien.
• Tuning av hyperparametre er en tidkrevende prosess, men nødvendig for å sikre at agentene våre lærer. Dette skal vi bli bedre på etter hvert som kurset skrider frem.

Hjemmelekser

notatbøker/04_hjemmearbeid.ipynb

Dette er hva jeg vil at du skal gjøre:

1. Git klone repoen til din lokale maskin.
2. Oppsett miljøet for denne leksjonen 01_taxi.
3. Åpen 01_taxi/notebooks/04_homework.ipynb og prøv å fullføre de 2 utfordringene.

Jeg kaller dem utfordringer (ikke øvelser) fordi de ikke er lette. Jeg vil at du skal prøve dem, skitne hendene dine og (kanskje) lykkes.

I den første utfordringen utfordrer jeg deg til å oppdatere train()-funksjonen src/loops.py for å godta en episodeavhengig epsilon.

I den andre utfordringen vil jeg at du skal oppgradere Python-ferdighetene dine og implementere parallellbehandling for å fremskynde eksperimentering med hyperparametere.

Som vanlig, hvis du står fast og trenger tilbakemelding, send meg en telefon på [e-postbeskyttet]

Jeg hjelper deg mer enn gjerne.

Hvis du ønsker å få oppdateringer om kurset, abonner på datamaskiner nyhetsbrev.

original. Ompostet med tillatelse.

Kilde: https://www.kdnuggets.com/2021/12/hands-on-reinforcement-learning-part-2.html