I klassisk programmering blir programvareinstruksjoner eksplisitt laget av programmerere, og ingenting læres av dataene i det hele tatt. I motsetning til dette er maskinlæring et felt innen informatikk som bruker statistiske metoder for å gjøre det mulig for datamaskiner å lære og utvinne kunnskap fra dataene uten å være eksplisitt programmert.

I denne opplæringsveiledningen for forsterkning vil jeg vise hvordan vi kan bruke PyTorch til å lære et neuralt nettverk av forsterkningslæring hvordan vi spiller Flappy Bird. Men først må vi dekke et antall byggesteiner.

Maskinlæringsalgoritmer kan grovt sett deles inn i to deler: Tradisjonelle læringsalgoritmer og dyp læring algoritmer. Tradisjonelle læringsalgoritmer har vanligvis mye færre lærbare parametere enn dyplæringsalgoritmer og har mye mindre læringskapasitet.

Tradisjonelle læringsalgoritmer er heller ikke i stand til å gjøre det funksjonsekstraksjon : Spesialister på kunstig intelligens må finne ut en god datarepresentasjon som deretter sendes til læringsalgoritmen. Eksempler på tradisjonelle maskinlæringsteknikker inkluderer SVM, tilfeldig skog, beslutningstreet og $ k $ -midler, mens den sentrale algoritmen i dyp læring er dype nevrale nettverk .

Inndataene til et dypt nevralt nettverk kan være rå bilder, og en spesialist for kunstig intelligens trenger ikke å finne noen datarepresentasjon - nevralt nettverk finner den beste representasjonen under treningsprosessen.

Mange dype læringsteknikker har vært kjent i veldig lang tid, men nylige fremskritt innen maskinvare økte raskt forskning og utvikling for dyp læring. Nvidia er ansvarlig for utvidelsen av feltet fordi GPU-ene har muliggjort raske dyplæringseksperimenter.

Lærbare parametere og hyperparametere

Maskinlæringsalgoritmer består av lærbare parametere som er innstilt i treningsprosessen og ikke-lærbare parametere som er satt før treningsprosessen. Parametere angitt før læring kalles hyperparametere .

Rutenett søk er en vanlig metode for å finne de optimale hyperparametrene. Det er en brute-force-metode: Det betyr å prøve alle mulige kombinasjoner av hyperparametere over et definert område og velge kombinasjonen som maksimerer en forhåndsdefinert beregning.

Overvåket, uten tilsyn og forsterkning læringsalgoritmer

En måte å klassifisere læringsalgoritmer på er å trekke en linje mellom overvåket og ikke-overvåket algoritmer. (Men det er ikke nødvendigvis så greit: Forsterkningslæring ligger et sted mellom disse to typene.)

Når vi snakker om veiledet læring, ser vi på $ (x_i, y_i) $ par. $ x_i $ er algoritmens input og $ y_i $ er output. Vår oppgave er å finne en funksjon som gjør riktig kartlegging fra $ x_i $ til $ y_i $.

For å stille inn lærbare parametere slik at de definerer en funksjon som tilordner $ x_i $ til $ y_i $, må det defineres en tapsfunksjon og en optimizer. En optimizer minimerer tapfunksjonen. Et eksempel på en tapsfunksjon er gjennomsnittlig kvadratfeil (MSE):

[MSE = sum_ {i = 1} ^ {n} (y_i - widehat {y_i}) ^ 2 ]

Her er $ y_i $ en grunnleggende sannhetsetikett og $ widehat {y_i} $ er en forutsagt etikett. En optimizer som er veldig populær innen dyp læring er stokastisk gradient nedstigning . Det er mange variasjoner som prøver å forbedre metoden for stokastisk nedstigning: Adam, Adadelta, Adagrad, og så videre.

Uovervåket algoritmer prøver å finne struktur i dataene uten eksplisitt å få etiketter. $ k $ -means er et av eksemplene på algoritmer uten tilsyn som prøver å finne optimale klynger i dataene. Nedenfor er et bilde med 300 datapunkter. $ k $ - betyr algoritmer som fant strukturen i dataene og tildelte et klyngemerke til hvert datapunkt. Hver klynge har sin egen farge.

Forsterkningslæring bruker belønninger: Sparsomme, tidsforsinkede etiketter. En agent tar handling, som endrer miljøet, hvorfra den kan få en ny observasjon og belønning. En observasjon er stimulansen en agent oppfatter fra miljøet. Det kan være hva agenten ser, hører, lukter og så videre.

En belønning gis til agenten når den tar en handling. Det forteller agenten hvor god handlingen er. Ved å oppfatte observasjoner og belønninger lærer en agent hvordan man optimalt oppfører seg i miljøet. Jeg kommer nærmere inn på dette nedenfor.

Aktiv, passiv og omvendt forsterkningslæring

Det er noen forskjellige tilnærminger til denne teknikken. Først og fremst er det aktiv forsterkningslæring, som vi bruker her. Derimot er det passiv forsterkningslæring, der belønning bare er en annen type observasjon, og avgjørelser i stedet tas i henhold til en fast policy.

Til slutt prøver invers forsterkningslæring å rekonstruere en belønningsfunksjon gitt historien til handlinger og deres belønning i forskjellige stater.

Generalisering, overmontering og underkledning

Enhver fast forekomst av parametere og hyperparametere kalles en modell. Maskinlæringseksperimenter består vanligvis av to deler: Opplæring og testing.

Under treningsprosessen blir innlærbare parametere innstilt ved hjelp av treningsdata. I testprosessen fryses lærbare parametere, og oppgaven er å sjekke hvor godt modellen gir spådommer på tidligere usete data. Generalisering er evnen til en læringsmaskin til å utføre nøyaktig på et nytt, usett eksempel eller oppgave etter å ha opplevd et læringsdatasett.

Hvis en modell er for enkel med hensyn til dataene, vil den ikke kunne passe på treningsdataene, og den vil fungere dårlig både på treningsdatasettet og testdatasettet. I så fall sier vi at modellen er underfitting .

Hvis en maskinlæringsmodell klarer seg bra på et treningsdatasett, men dårlig på et testdatasett, sier vi at det er det overmontering . Overmontering er situasjonen der en modell er for kompleks med hensyn til dataene. Det passer perfekt til treningsdata, men det er tilpasset så mye til treningsdatasettet at det fungerer dårlig på testdata, det vil si at det ganske enkelt ikke generaliserer.

Nedenfor er et bilde som viser under- og overmontering sammenlignet med en balansert situasjon mellom de samlede dataene og prediksjonsfunksjonen.

Skalerbarhet

Data er avgjørende for å bygge maskinlæringsmodeller. Vanligvis krever tradisjonelle læringsalgoritmer ikke for mye data. Men på grunn av deres begrensede kapasitet er ytelsen også begrenset. Nedenfor er et diagram som viser hvordan dype læringsmetoder skalerer seg bra sammenlignet med tradisjonelle maskinlæringsalgoritmer.

Nevrale nettverk

Nevrale nettverk består av flere lag. Bildet nedenfor viser et enkelt nevralt nettverk med fire lag. Det første laget er inngangslaget, og det siste laget er utgangslaget. De to lagene mellom inngangs- og utgangslagene er skjulte lag.

Hvis et nevralt nettverk har mer enn ett skjult lag, kaller vi det et dypt nevralt nettverk. Inngangssettet $ X $ blir gitt til nevrale nettverk og utdata $ y $ er oppnådd. Læring gjøres ved hjelp av en backpropagation algoritme som kombinerer en tapsfunksjon og en optimizer.

Backpropagation består av to deler: en fremoverpasning og en bakoverpasning. I fremoverpasset blir inngangsdata lagt på inngangen til nevralt nettverk og utgang er oppnådd. Tapet mellom bakkesannheten og spådommen beregnes, og i bakoverpasningen blir nevrale nettverksparametere innstilt med tanke på tapet.

Convolutional Neural Network

En nevral nettverksvariasjon er konvolusjonelle nevrale nettverk . Den brukes primært til datasynoppgaver.

Det viktigste laget i konvolusjonelle nevrale nettverk er konvolusjonslaget (derav navnet). Parametrene er laget av lærbare filtre, også kalt kjerner. Konvolusjonslag bruker en konvolusjonsoperasjon på inngangen, og overfører resultatet til neste lag. Konvolusjonsoperasjonen reduserer antall lærbare parametere, fungerer som en slags heuristikk og gjør det nevrale nettverket lettere å trene.

Nedenfor er hvordan en konvolusjonskjerne i et konvolusjonslag fungerer. Kjernen påføres bildet og en innviklet funksjon oppnås.

ReLU-lag brukes til å introdusere ikke-lineariteter i nevrale nettverk. Ikke-lineariteter er viktige fordi vi med dem kan modellere alle slags funksjoner, ikke bare lineære, noe som gjør nevrale nettverk til en universell funksjonsnærmer. Dette gjør at en ReLU-funksjon defineres slik:

[ReLU = max (0, x) ]

ReLU er et av eksemplene på såkalt aktiveringsfunksjoner brukt til å innføre ikke-lineariteter i nevrale nettverk. Eksempler på andre aktiveringsfunksjoner inkluderer sigmoid- og hyper-tangentfunksjoner. ReLU er den mest populære aktiveringsfunksjonen fordi det er vist at det gjør at nevrale nettverk trener mer effektivt sammenlignet med andre aktiveringsfunksjoner.

Nedenfor er en oversikt over en ReLU-funksjon.

Som du kan se, endrer denne ReLU-funksjonen bare negative verdier til nuller. Dette hjelper til med å forhindre forsvinningsgradsproblemet . Hvis en gradient forsvinner, vil den ikke ha stor innvirkning på innstillingen av nevrale nettverkets vekt.

Et konvolusjonalt nevralt nettverk består av flere lag: Konvolusjonslag, ReLU-lag og fullt tilkoblede lag. Fullt sammenkoblede lag forbinder hvert nevron i ett lag til hvert nevron i et annet lag, sett med de to skjulte lagene i bildet i begynnelsen av denne delen. Det siste fullt tilkoblede laget kartlegger utganger fra forrige lag til, i dette tilfellet, number_of_actions verdier.

applikasjoner

Dyp læring er vellykket og overgår klassiske maskinlæringsalgoritmer i flere maskinlæringsfelt, inkludert datasyn, talegjenkjenning og forsterkningslæring. Disse feltene for dyp læring brukes i forskjellige virkelige domener: økonomi, medisin, underholdning, etc.

Forsterkningslæring

Forsterkningslæring er basert på en middel . En agent tar handlinger i et miljø og får observasjoner og belønninger fra det. En agent må trenes for å maksimere kumulativ belønning. Som nevnt innledningsvis, med klassiske maskinlæringsalgoritmer, må maskinlæringsingeniører utføre funksjonutvinning, dvs. lage gode funksjoner som representerer miljøet godt og som mates inn i en maskinlæringsalgoritme.

Ved å bruke dyp læring er det mulig å lage et end-to-end-system som tar høydimensjonale input - f.eks. video - og av det lærer den den optimale strategien for en agent å ta gode handlinger.

I 2013 skapte London AI-oppstart DeepMind et stort gjennombrudd i å lære å kontrollere agenter direkte fra høydimensjonale sensoriske innganger. De ga ut et papir, Spiller Atari med dyp forsterkningslæring , der de viste hvordan de lærte et kunstig nevralt nettverk å spille Atari-spill bare fra å se på skjermen. De ble anskaffet av Google, og deretter publisert et nytt papir i Natur med noen forbedringer: Kontroll på menneskelig nivå gjennom dyp forsterkningslæring .

I motsetning til andre maskinlæringsparadigmer, har forsterkningslæring ikke en veileder, bare et belønningssignal. Tilbakemelding er forsinket: Det er ikke øyeblikkelig som i overvåket læringsalgoritmer. Data er sekvensielle og handlinger fra en agent påvirker de påfølgende dataene de mottar.

Nå er en agent lokalisert i sitt miljø, som er i en viss tilstand. For å beskrive dette mer detaljert bruker vi en Markov-beslutningsprosess, som er en formell måte å modellere dette forsterkende læringsmiljøet på . Den består av et sett med stater, et sett med mulige handlinger og regler (for eksempel sannsynligheter) for overgang fra en stat til en annen.

Agenten er i stand til å utføre handlinger og transformere miljøet. Vi kaller belønningen $ R_t $. Det er et skalar-tilbakemeldingssignal som indikerer hvor godt agenten klarer seg i trinn $ t $.

For god langsiktig ytelse må ikke bare umiddelbare belønninger, men også fremtidige belønninger tas i betraktning. Den totale belønningen for en episode fra trinn $ t $ er $ R_t = r_t + r_ {t + 1} + r_ {t + 2} + ldots + r_n $. Fremtiden er usikker, og jo lenger vi går i fremtiden, jo flere fremtidige spådommer kan avvike. På grunn av dette brukes en rabattert fremtidig belønning: $ R_t = r_t + gamma r_ {t + 1} + gamma ^ 2r_ {t + 2} + ldots + gamma ^ {nt} r_n = r_t + gamma R_ {t + 1} $. En agent bør velge handlingen som maksimerer den nedsatte fremtidige belønningen.

Dyp Q-læring

Funksjonen $ Q (s, a) $ representerer den maksimale rabatterte fremtidige belønningen når handling $ a $ utføres i staten $ s $:

[Q (s_t, a_t) = max R_ {t + 1} ]

Estimeringen av en fremtidig belønning er gitt av Bellman-ligningen: $ Q (s, a) = r + gamma max_ {a ’} Q (s’, a ’) $. Med andre ord, den maksimale fremtidige belønningen gitt en stat $ s $ og en handling $ a $ er den umiddelbare belønningen pluss maksimal fremtidig belønning for neste stat.

Tilnærmingen av Q-verdier ved hjelp av ikke-lineære funksjoner (nevrale nettverk) er ikke veldig stabil. På grunn av dette blir erfaringsspilling brukt for stabilitet. Erfaring under episoder i en treningsøkt lagres i et replay-minne. Tilfeldige mini-batcher fra repriseringsminnet brukes i stedet for å bruke den siste overgangen. Dette bryter likheten med påfølgende treningsprøver som ellers ville føre nevrale nettverk til et lokalt minimum.

Det er to viktige aspekter å nevne om dyp Q-læring: leting og utnyttelse. Med utnyttelse tas den beste avgjørelsen gitt den aktuelle informasjonen. Leting samler mer informasjon.

Når algoritmen utfører en handling foreslått av nevrale nettverk, gjør den utnyttelse: Den utnytter nevralt nettverks lærte kunnskap. Derimot kan en algoritme ta en tilfeldig handling, utforske nye muligheter og introdusere potensiell ny kunnskap i nevrale nettverk.

'Deep Q-learning algoritme med Experience Replay' fra DeepMinds papir Spiller Atari med dyp forsterkningslæring er vist nedenfor.

DeepMind refererer til konvolusjonsnettverk trent med sin tilnærming som Deep Q-nettverk (DQN).

Dypt Q-læringseksempel ved bruk av Flappy Bird

Flappy Bird var et populært mobilspill som opprinnelig ble utviklet av vietnamesisk videospillartist og programmerer Dong Nguyen. I den kontrollerer spilleren en fugl og prøver å fly mellom grønne rør uten å treffe dem.

Nedenfor er et skjermbilde fra en Flappy Bird-klon kodet ved hjelp av PyGame :

Klonen har siden blitt forked og modifisert: Bakgrunnen, lydene og forskjellige fugler og rørstiler er fjernet, og koden er justert, slik at den enkelt kan brukes med enkle læringsrammer for forsterkning. Den modifiserte spillmotoren er hentet fra dette TensorFlow-prosjektet :

Men i stedet for å bruke TensorFlow, har jeg bygget et dypt forsterkende læringsrammeverk ved hjelp av PyTorch. PyTorch er en dyp læringsramme for rask, fleksibel eksperimentering. Det gir tensorer og dynamiske nevrale nettverk i Python med sterk GPU-akselerasjon.

Nevrale nettverksarkitektur er den samme som DeepMind brukt i papiret Kontroll på menneskelig nivå gjennom dyp forsterkningslæring .

Lag	Inngang	Filterstørrelse	Stride	Antall filtre	Aktivering	Produksjon
conv1	84x84x4	8x8	4	32	ReLU	20x20x32
conv2	20x20x32	4x4	2	64	ReLU	9 x 9 x 64
conv3	9 x 9 x 64	3 x 3	en	64	ReLU	7 x 7 x 64
FC4	7 x 7 x 64			512	ReLU	512
fc5	512			2	Lineær	2

Det er tre konvolusjonslag og to fullt sammenkoblede lag. Hvert lag bruker ReLU-aktivering, bortsett fra det siste, som bruker lineær aktivering. Nevrale nettverk gir ut to verdier som representerer spillerens eneste mulige handlinger: 'Fly opp' og 'gjør ingenting.'

Inngangen består av fire påfølgende 84x84 svart-hvitt-bilder. Nedenfor er et eksempel på fire bilder som blir matet til nevrale nettverk.

Du vil merke at bildene er rotert. Det er fordi utgangen fra klonens spillmotor roteres. Men hvis nevrale nettverk blir undervist og deretter testet med slike bilder, vil det ikke påvirke ytelsen.

Du kan også legge merke til at bildet er beskåret slik at gulvet er utelatt, fordi det er irrelevant for denne oppgaven. Alle piksler som representerer rør og fuglen er hvite, og alle piksler som representerer bakgrunnen er svarte.

Dette er en del av koden som definerer nevrale nettverk. Vektene på nevrale nettverk er initialisert for å følge den jevne fordelingen $ mathcal {U} (- 0.01, 0.01) $. Bias-delen av nevrale nettverkers parametere er satt til 0.01. Flere forskjellige initialiseringer ble prøvd (Xavier uniform, Xavier normal, Kaiming uniform, Kaiming normal, uniform og normal), men initialiseringen ovenfor gjorde at nevrale nettverk konvergerte og trente raskest. Størrelsen på nevrale nettverk er 6,8 MB.

class NeuralNetwork(nn.Module): def __init__(self): super(NeuralNetwork, self).__init__() self.number_of_actions = 2 self.gamma = 0.99 self.final_epsilon = 0.0001 self.initial_epsilon = 0.1 self.number_of_iterations = 2000000 self.replay_memory_size = 10000 self.minibatch_size = 32 self.conv1 = nn.Conv2d(4, 32, 8, 4) self.relu1 = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(32, 64, 4, 2) self.relu2 = nn.ReLU(inplace=True) self.conv3 = nn.Conv2d(64, 64, 3, 1) self.relu3 = nn.ReLU(inplace=True) self.fc4 = nn.Linear(3136, 512) self.relu4 = nn.ReLU(inplace=True) self.fc5 = nn.Linear(512, self.number_of_actions) def forward(self, x): out = self.conv1(x) out = self.relu1(out) out = self.conv2(out) out = self.relu2(out) out = self.conv3(out) out = self.relu3(out) out = out.view(out.size()[0], -1) out = self.fc4(out) out = self.relu4(out) out = self.fc5(out) return out

I konstruktøren vil du legge merke til at det er definert hyperparametere. Hyperparameteroptimalisering gjøres ikke for formålet med dette blogginnlegget. I stedet brukes hyperparametere for det meste fra DeepMinds papirer. Her er noen av hyperparametrene skalert til å være lavere enn i DeepMinds papir, fordi Flappy Bird er mindre komplisert enn Atari-spillene de brukte til tuning.

Dessuten er epsilon endret til å være mye mer rimelig for dette spillet. DeepMind bruker en epsilon av en, men her bruker vi 0,1. Dette er fordi høyere epsiloner tvinger fuglen til å klappe mye, noe som skyver fuglen mot skjermens øvre kant, og til slutt resulterer det i at fuglen krasjer i et rør.

Forsterkningslæringskoden har to modi: Tren og test. I løpet av testfasen kan vi se hvor godt forsterkningslæringsalgoritmen har lært å spille spillet. Men først må nevrale nettverk trenes. Vi må definere tapsfunksjonen som skal minimeres, og optimaliserere som vil minimere tapsfunksjonen. Vi bruker Adam optimaliseringsmetode og gjennomsnittlig kvadratfeil for tapsfunksjonen:

optimizer = optim.Adam(model.parameters(), lr=1e-6) criterion = nn.MSELoss()

Spillet skal instantieres:

game_state = GameState()

Replay-minne er definert som en Python-liste:

replay_memory = []

Nå må vi initialisere den første tilstanden. En handling er todimensjonal tensor:

• [1, 0] representerer “gjør ingenting”
• [0, 1] representerer “fly opp”

frame_step metoden gir oss neste skjerm, belønning og informasjon om neste status er terminal. Belønningen er 0.1 for hver fugles trekk uten å dø når den ikke går gjennom et rør, 1 hvis fuglen lykkes gjennom et rør og -1 hvis fuglen krasjer.

resize_and_bgr2gray funksjon beskjærer gulvet, endrer størrelsen på skjermen til et 84x84-bilde og endrer fargeområdet fra BGR til svart-hvitt. image_to_tensor funksjon konverterer bildet til en PyTorch tensor og plasserer det i GPU-minne hvis CUDA er tilgjengelig. Til slutt sammenkobles de siste fire sekvensielle skjermene og er klare til å sendes til nevrale nettverk.

action = torch.zeros([model.number_of_actions], dtype=torch.float32) action[0] = 1 image_data, reward, terminal = game_state.frame_step(action) image_data = resize_and_bgr2gray(image_data) image_data = image_to_tensor(image_data) state = torch.cat((image_data, image_data, image_data, image_data)).unsqueeze(0)

Den første epsilonen er satt ved hjelp av denne kodelinjen:

epsilon = model.initial_epsilon

Den viktigste uendelige løkken følger. Kommentarer er skrevet i koden, og du kan sammenligne koden med Deep Q-learning med Experience Replay-algoritmen skrevet ovenfor.

Algoritmen prøver minibatcher fra replay-minne og oppdaterer nevrale nettverkets parametere. Handlingene utføres ved hjelp av epsilon grådig leting . Epsilon blir glødet over tid. Tapsfunksjonen som minimeres er $ L = frac {1} {2} left [ max_ {a ’} Q (s’, a ’) - Q (s, a) right] ^ 2 $. $ Q (s, a) $ er den grunnleggende sannhetsverdien beregnet ved hjelp av Bellman-ligningen og $ max_ {a ’} Q (s’, a ’) $ er hentet fra det nevrale nettverket. Nevrale nettverk gir to Q-verdier for de to mulige handlingene, og algoritmen tar handlingen med høyest Q-verdi.

while iteration

Nå som alle delene er på plass, her er en oversikt på høyt nivå av dataflyten ved hjelp av vårt nevrale nettverk:

Her er en kort sekvens med et opplært nevralt nettverk.

Nevrale nettverk vist ovenfor ble trent ved hjelp av en avansert Nvidia GTX 1080 GPU i noen timer; bruker en CPU-basert løsning i stedet, vil denne spesielle oppgaven ta flere dager. Spillmotorens FPS ble satt til et veldig stort antall under trening: 999 ... 999 - med andre ord så mange bilder per sekund som mulig. I testfasen ble FPS satt til 30.

Nedenfor er et diagram som viser hvordan den maksimale Q-verdien endret seg under iterasjoner. Hver 10 000. iterasjon vises. En nedadgående pigg betyr at for en bestemt ramme (en iterasjon er en ramme), forutser nevrale nettverk at fuglen vil få en veldig lav belønning i fremtiden - det vil si at den vil krasje veldig snart.

Full kode og forhåndsøvd modell er tilgjengelig her .

Dyp forsterkningslæring: 2D, 3D og til og med virkelige liv

I denne opplæringsveiledningen for PyTorch-forsterkning viste jeg hvordan en datamaskin kan lære å spille Flappy Bird uten noen tidligere kunnskap om spillet, ved å bare bruke en prøve-og-feil-tilnærming som et menneske ville gjort når man møter spillet for første gang.

Det er interessant at algoritmen kan implementeres i noen få kodelinjer ved hjelp av PyTorch-rammeverket. Papiret som metoden i denne bloggen er basert på er relativt gammelt, og mange nyere papirer med forskjellige modifikasjoner som muliggjør raskere konvergens er tilgjengelig. Siden da har dyp forsterkningslæring blitt brukt til å spille 3D-spill og i virkelige robotsystemer.

Bedrifter som DeepMind , Maluuba , og Vicarious jobber intensivt med dyp forsterkningslæring. Slik teknologi ble brukt i AlphaGo, som slo Lee Sedol, en av verdens beste spillere på Go. På den tiden ble det ansett at det ville ta minst ti år før maskiner kunne beseire de beste spillerne på Go.

Flommen av interesse og investeringer i dyp forsterkningslæring (og i kunstig intelligens generelt) kan til og med føre til potensiell kunstig generell intelligens (AGI) - intelligens på menneskelig nivå (eller til og med videre) som kan uttrykkes i form av en algoritme og simuleres på datamaskiner. Men AGI må være gjenstand for en annen artikkel.

---

Referanser:

• Avmystifisering av dyp forsterkningslæring
• Dyp forsterkningslæring for Flappy Bird
• “Convolutional neural network” på Wikipedia
• “Forsterkningslæring” på Wikipedia
• “Markov beslutningsprosess” på Wikipedia
• University College London kurs på RL

I slekt: En Deep Learning Tutorial: Fra Perceptrons til Deep Networks

Forstå det grunnleggende

Hva er læring uten tilsyn?

Uovervåket læring er en tilnærming til maskinlæring som finner struktur i data. I motsetning til med veiledet læring, er ikke data merket.

Hva er passiv forsterkningslæring?

I passiv forsterkningslæring lærer agenten og følger en policy. Det får 'belønninger', men kan bare observere dem, enten de er gode eller ikke. I kontrast har aktiv forsterkningslæring agenter som lærer seg å ta den beste handlingen for hver stat for å maksimere kumulative fremtidige belønninger.

Hva er invers forsterkningslæring?

I forsterkningslæring har en agent tilgang til tilbakemelding i form av en 'belønning' hver gang den tar noen handling i en eller annen tilstand i miljøet. Invers forsterkning læring prøver å rekonstruere en belønningsfunksjon gitt historien om belønninger mottatt for handlinger i visse stater.

Hva er typene nevrale nettverk?

Mange nevrale nettverkstyper er basert på kombinasjonene av lagene de bruker, f.eks. konvolusjonslag, fullkoblede lag og LSTM-lag. Typer av nevrale nettverk inkluderer revolusjonære nevrale nettverk (CNN), tilbakevendende nevrale nettverk (RNN) og flerlags perceptron (MLP eller 'vanilje') nevrale nettverk.

Hva er DeepMind AI?

DeepMind Technologies Limited er et London-basert kunstig intelligensfirma. De utviklet AlphaGo, som slo Lee Sedol, en verdensmester i Go. Selskapet ble kjøpt opp av Google i 2014.