Reinforcement Learning

Vi har sett hur övervakad inlärning lär sig från ett facit och hur oövervakad inlärning hittar mönster i ostrukturerad data. Nu är det dags för den tredje stora pelaren inom maskininlärning: Reinforcement Learning (RL), eller förstärkningsinlärning.

Här är inlärningsprocessen helt annorlunda. Istället för att passivt analysera en färdig datamängd, lär sig en RL-modell genom att aktivt agera i en miljö och lära sig av konsekvenserna av sina handlingar. Det är en process av trial-and-error, precis som när ett barn lär sig att gå eller en hund lär sig ett trick.

Kärnkomponenterna: Agent, Miljö, Belöning

Kärnan i Reinforcement Learning kan kokas ner till några grundläggande koncept:

Agenten: Vår AI-modell, den som ska lära sig.
Miljön: Den värld, verklig eller simulerad, som agenten agerar i.
Tillstånd (State): En ögonblicksbild av miljön.
Handling (Action): De möjliga beslut agenten kan ta.
Belöning (Reward): En omedelbar signal från miljön som talar om för agenten om dess handling var bra eller dålig.

Men för att en agent ska kunna lära sig systematiskt behöver vi ett formellt sätt att beskriva detta samspel. Vi behöver en karta och en regelbok för agentens värld.

Byggsten 1: Spelets Regler (Markov Decision Process)

Innan en agent kan lära sig den bästa strategin, måste vi definiera "spelet" den spelar. Inom RL görs detta med ett matematiskt ramverk som kallas Markov Decision Process (MDP). En MDP är en formell beskrivning av miljön och består av fyra huvudingredienser:

En uppsättning Tillstånd (S): Alla möjliga situationer agenten kan befinna sig i. I schack är detta alla giltiga positioner för pjäserna på brädet.
En uppsättning Handlingar (A): Alla möjliga drag agenten kan göra. I schack är detta alla lagliga drag från ett givet tillstånd.
En övergångsmodell (P): Reglerna för hur miljön förändras. Den specificerar sannolikheten att hamna i ett nytt tillstånd (s') om agenten utför en viss handling (a) i ett visst tillstånd (s). För de flesta spel (som schack eller en labyrint) är detta deterministiskt: om du flyttar pjäsen till ruta E4, hamnar den på ruta E4 med 100% sannolikhet. I mer komplexa miljöer, som robotik, kan det finnas osäkerhet (robotarmen kanske bara lyckas greppa objektet 95% av gångerna).
En belöningsfunktion (R): Specificerar belöningen. Denna funktion är kritisk och dess design är en hel vetenskap. Den kan vara gles (sparse), där agenten bara får en belöning vid slutet av spelet (t.ex. +1 för vinst, -1 för förlust, och 0 för alla hundratals drag däremellan). Detta gör inlärningen mycket svår, eftersom agenten sällan får feedback. Mer vanligt är att man designar en tät (dense) belöningsfunktion som ger omedelbar, mindre feedback för fördelaktiga handlingar, som att ta en av motståndarens pjäser eller förbättra sin position på brädet. Detta vägleder agenten och snabbar på inlärningen avsevärt. Det som verkligen definierar en MDP är dock en fundamental egenskap som kallas Markov-egenskapen (The Markov Property).

Markov-egenskapen: Schackbrädesprincipen

Markov-egenskapen säger att framtiden är oberoende av det förflutna, givet nuet.

Det låter abstrakt, men är extremt intuitivt om vi tänker på ett schackbräde. För att bestämma ditt bästa nästa drag behöver du bara känna till den nuvarande positionen av alla pjäser. Det spelar absolut ingen roll vilka drag som ledde fram till den positionen. Hela historien är komprimerad i det nuvarande tillståndet. Du behöver inte komma ihåg att "motståndaren flyttade sin springare för fem drag sedan". All relevant information finns på brädet just nu.

Detta är "minneslöshetsegenskapen". Agenten behöver inte komma ihåg hela sin historia för att fatta ett optimalt beslut; den nuvarande observationen är tillräcklig.

När ett problem kan beskrivas som en MDP (med tillstånd, handlingar, övergångar, belöningar och Markov-egenskapen), har vi en väldefinierad struktur. Målet för Reinforcement Learning blir då att hitta en optimal policy (π*). En policy är helt enkelt agentens strategi – en regelbok som talar om vilken handling som är bäst att utföra i varje givet tillstånd för att maximera den totala framtida belöningen.

Byggsten 2: Agentens Minne (Q-tabellen)

Hur hittar agenten denna optimala policy? Den måste ha ett minne för att komma ihåg vilka handlingar som tenderade att vara bra i vilka situationer. En av de mest grundläggande metoderna för detta kallas Q-learning, och den använder en enkel tabell som agentens "hjärna".

Denna tabell kallas en Q-tabell. Tänk dig den som ett fuskblad för livet. Raderna representerar varje möjligt tillstånd (State) och kolumnerna representerar varje möjlig handling (Action). Siffran i varje cell, Q-värdet, är agentens uppskattning av den totala framtida belöningen den kommer att få om den utför den handlingen i det tillståndet.

Analogin: Musen i labyrinten Föreställ dig en mus (agent) i en labyrint (miljö) som följer reglerna i en MDP. Målet är att hitta osten (stor belöning). Vissa rutor har en elektrisk stöt (negativ belöning). Musens Q-tabell skulle kunna se ut så här i början (allt är 0, den vet ingenting):

Tillstånd (Position)	Gå Upp	Gå Ner	Gå Vänster	Gå Höger
Start (A1)	0	0	0	0
Ruta A2	0	0	0	0
...	...	...	...	...

TODO Illustration: Q-tabellen som Fuskblad

En illustration som visar en enkel 3x3-labyrint. I en ruta finns en ost, i en annan en fälla. Bredvid labyrinten, visa en tabell (Q-tabellen) med rader för varje ruta (A1, A2...) och kolumner för handlingar (Upp, Ner, Vänster, Höger). Cellen för rutan bredvid osten och handlingen "Gå Höger" ska vara färgad starkt grön och innehålla ett högt positivt tal (t.ex. +90), för att visa hur ett högt Q-värde fungerar som en "brödsmula" mot belöningen.

Byggsten 3: Lärande genom Uppdatering (Bellman-ekvationen)

Nu börjar inlärningen. Musen rör sig slumpmässigt.

Första steget: Musen är i Start (A1) och väljer slumpmässigt att Gå Höger till Ruta A2. Miljön är neutral, så den får belöningen 0.
Andra steget: Från A2 väljer den att Gå Ner och hamnar i Ruta B2. JACKPOTT! Den hittar osten och får en belöning på +100.
Lärdomen (Uppdateringen): Nu händer magin. Musen uppdaterar sin Q-tabell. Den tänker baklänges: "Att jag Gick Ner när jag var i A2 var en fantastisk idé! Det ledde direkt till +100 i belöning." Agenten uppdaterar därför Q-värdet för kombinationen (Tillstånd: A2, Handling: Gå Ner) till ett högt positivt värde.

Den exakta formeln (förenklat kallad Bellman-ekvationen) ser ut ungefär så här:

Nytt Q-värde = Gammalt Q-värde + Lärandefaktor * (Omedelbar belöning + Framtida belöning - Gammalt Q-värde)

Det viktiga här är termen Framtida belöning. Agenten tittar på det nya tillståndet den hamnade i (B2, osten) och frågar: "Vad är det bästa jag kan göra härifrån?". Detta gör att belöningar kan "propagera bakåt" genom labyrinten. Efter tusentals försök kommer höga Q-värden att ha spridit sig från osten bakåt längs den optimala vägen.

Den exakta uppdateringsregeln, som är en tillämpning av den mer generella Bellman-ekvationen, ser ut så här:

Q(s, a) ← Q(s, a) + α [R + γ max_a' Q(s', a') - Q(s, a)]

Låt oss bryta ner denna formel, som är hjärtat i Q-learning:

Q(s, a) är det nuvarande Q-värdet för att ta handling a i tillstånd s.
α (alfa) är inlärningsfaktorn (learning rate), ett litet tal som styr hur mycket vi uppdaterar vårt gamla värde med ny information.
R är den omedelbara belöningen vi fick.
γ (gamma) är diskonteringsfaktorn (discount factor). Detta tal (mellan 0 och 1) avgör hur mycket agenten värderar framtida belöningar. Ett γ nära 1 betyder att agenten är "patient" och värderar en framtida belöning nästan lika högt som en omedelbar. Ett γ nära 0 gör agenten "kortsiktig" och fokuserad på omedelbar vinning.
max_a' Q(s', a') är den avgörande termen. Den representerar den maximala framtida belöningen. Agenten tittar på det nya tillståndet s' och frågar: "Vilken är den bästa handlingen jag kan ta härifrån, och vad är det uppskattade värdet på den?".
[R + γ max_a' Q(s', a') - Q(s, a)] är felet (Temporal Difference Error). Det är skillnaden mellan den nya, uppdaterade uppskattningen av värdet (omedelbar belöning + diskonterad framtida belöning) och vår gamla uppskattning. Vi justerar vårt gamla Q-värde med en liten del (styrd av α) av detta fel.

Som exempel, låt oss följa musen i labyrinten. Musens Q-tabell är helt tom från början (alla värden är 0).

Försök #1: Den Lyckliga Slumpen

Musen vandrar helt slumpmässigt. Den tar en massa meningslösa steg.
Till slut, av ren tur, befinner den sig i ruta C3, precis bredvid osten.
Den väljer slumpmässigt att gå Höger och hamnar i ruta D3 (osten!).
AHA-ÖGONBLICKET! Miljön ger den en belöning på +100. Nu sker den allra första inlärningen. Algoritmen uppdaterar en enda cell i Q-tabellen:
- Q(tillstånd: C3, handling: Höger) sätts till ett högt värde, låt oss säga +100.
Musen har nu lärt sig en enda, specifik sak: "Om du någonsin är i ruta C3, är det en fantastisk idé att gå höger." Resten av labyrinten är fortfarande ett totalt mysterium.

Försök #2: Den Första Brödsmulan

Musen startar om och vandrar slumpmässigt igen.
Efter ett tag hamnar den, återigen av en slump, i ruta B3.
Den väljer slumpmässigt att gå Ner och hamnar i ruta C3.
INLÄRNINGSÖGONBLICKET: Vad händer nu?
- Omedelbar belöning: Att gå från B3 till C3 ger 0 i belöning. C3 är bara en tom ruta.
- MEN... nu kickar "Framtida belöning"-delen in. Innan algoritmen uppdaterar värdet för Q(B3, Ner), tittar den på den ruta musen landade i (C3) och frågar: "Vad är det bästa möjliga värdet jag kan få från C3 och framåt?"
- Den slår upp detta i sin Q-tabell. Och se på fan! Den vet ju redan att Q(C3, Höger) är +100. Det är det högsta värdet den kan få från ruta C3.
- Algoritmen resonerar då så här: "Aha! Att gå Ner från B3 gav mig ingen omedelbar belöning, men det tog mig till en plats (C3) som jag vet är ett steg från en stor belöning. Därför måste handlingen 'Gå Ner' från 'B3' också vara värdefull!"
Algoritmen uppdaterar nu Q(B3, Ner) med ett värde som är en skugga av värdet från nästa steg (ofta lite mindre, t.ex. 90% av 100, vilket är +90).

Vad har hänt? Värdet +100 från osten har nu "smittat av sig" eller propagerat bakåt ett steg, från ruta C3 till ruta B3. Vi har nu lämnat en brödsmula i B3 som pekar mot C3.

Försök #3, #4, #5... Ekots spridning

Denna process upprepar sig. Nästa gång musen råkar gå från A3 till B3, kommer den att upptäcka att B3 har ett högt framtida värde (+90). Då kommer Q(A3, Ner) att få ett positivt värde (t.ex. 90% av 90, vilket är +81).

Efter tusentals försök har värdet från osten spridit sig bakåt genom hela labyrinten, som ringar på vattnet, och skapat en "motorväg" av höga Q-värden som leder från starten hela vägen till målet.

Det är så en framtida belöning formar nuvarande beslut – inte genom magi, utan genom en stegvis, bakåtgående inlärningsprocess över många repetitioner. När musen sedan startar ett nytt försök behöver den inte längre gissa. I varje ruta tittar den bara på sin Q-tabell, ser vilken handling som har det högsta värdet (den ljusaste "brödsmulan"), och följer den. Den har lärt sig en optimal policy.

Från Teori till Praktik: Q-learning i Python

Att förstå Bellman-ekvationen är en sak, men att se den i aktion är något helt annat. För att göra koncepten konkreta ska vi nu bygga en komplett Q-learning-agent från grunden i Python. Vi kommer att använda "musen i labyrinten"-analogin, men i en mer formell "grid-värld".

Steg 1: Bygg Intuition i en Text-baserad Lekplats

Innan vi automatiserar lärandet, låt oss först själva agera agent. Detta hjälper oss att få en intuitiv känsla för samspelet mellan tillstånd, handlingar och belöningar.

Vår värld är ett 3x3-rutnät.

S är startpositionen.
O är målet (osten), som ger +50 i belöning.
F är en fälla, som ger -50 i belöning.
Alla andra rutor (.) ger -1 i belöning för varje steg, för att uppmuntra agenten att hitta den snabbaste vägen.

. . .
. F .
S . O

Kör följande Python-kod. Den kommer att låta dig mata in kommandon (w=upp, a=vänster, s=ner, d=höger) och se hur ditt tillstånd och din totala poäng förändras. Försök att nå O!

# playground.py
def print_world(player_pos):
    world = [list(". . ."), list(". F ."), list("S . O")]
    world[player_pos[0]][player_pos[1]] = 'A' # Agent
    for row in world:
        print(" ".join(row))

def main():
    player_pos = [2, 0] # Start at 'S'
    total_reward = 0
    print("--- Välkommen till Grid-världen! ---")
    print("Mål: Nå osten (O) utan att hamna i fällan (F).")
    print("Kommandon: w (upp), a (vänster), s (ner), d (höger), q (avsluta)")
    
    while True:
        print_world(player_pos)
        move = input("Ditt drag: ")

        if move == 'q': break
        
        row, col = player_pos
        if move == 'w': row -= 1
        elif move == 's': row += 1
        elif move == 'a': col -= 1
        elif move == 'd': col += 1
        else:
            print("Ogiltigt kommando.")
            continue

        if not (0 <= row < 3 and 0 <= col < 3):
            print("Du gick in i en vägg! Försök igen.")
            continue
        
        player_pos = [row, col]
        
        if player_pos == [1, 1]: # Fällan
            total_reward -= 50
            print(f"AJ! Du hamnade i fällan! Poäng: {total_reward}. Spelet över.")
            break
        elif player_pos == [2, 2]: # Osten
            total_reward += 50
            print(f"GRATTIS! Du hittade osten! Poäng: {total_reward}. Spelet över.")
            break
        else:
            total_reward -= 1
            print(f"Du tog ett steg. Nuvarande poäng: {total_reward}")

if __name__ == "__main__":
    main()

Genom att spela detta själv märker du snabbt att vissa vägar är bättre än andra. Nu ska vi lära en AI att upptäcka den optimala vägen på egen hand.

Steg 2: Implementera Q-learning "From Scratch"

Nu bygger vi agenten som kan lära sig detta automatiskt. Koden nedan implementerar Q-learning-algoritmen vi diskuterade. Lägg märke till hur varje del av koden mappar direkt till koncepten: Q-tabellen, Bellman-ekvationen och exploration/exploitation-dilemmat.

# q_learning_agent.py
import random
import numpy as np

# 1. Definiera Miljön
rewards = {
    (0, 0): -1, (0, 1): -1, (0, 2): -1,
    (1, 0): -1, (1, 1): -50, (1, 2): -1, # Fälla vid (1,1)
    (2, 0): -1, (2, 1): -1, (2, 2): 50   # Ost vid (2,2)
}
actions = {'w': (-1, 0), 's': (1, 0), 'a': (0, -1), 'd': (0, 1)}
states = list(rewards.keys())

# 2. Initialisera Q-tabellen
# Vi använder en dictionary för att lagra Q-värden.
# Nyckeln är ett tillstånd (en tuple), och värdet är en annan dictionary
# som mappar varje handling till dess Q-värde.
q_table = {}
for state in states:
    q_table[state] = {action: 0 for action in actions}

# 3. Sätt Hyperparametrar
learning_rate = 0.1  # α (alpha)
discount_factor = 0.9 # γ (gamma)
episodes = 5000      # Antal "försök" agenten får
epsilon = 1.0        # Startvärde för exploration rate
epsilon_decay = 0.999 # Hur snabbt vi slutar utforska

# 4. Träningsloopen
for episode in range(episodes):
    state = (2, 0) # Starta alltid vid 'S'
    done = False
    
    while not done:
        # Exploration vs. Exploitation (Epsilon-Greedy)
        if random.uniform(0, 1) < epsilon:
            action_key = random.choice(list(actions.keys())) # Utforska
        else:
            # Hitta den bästa handlingen från Q-tabellen
            action_key = max(q_table[state], key=q_table[state].get) # Utnyttja

        # Utför handlingen
        move = actions[action_key]
        next_state = (state[0] + move[0], state[1] + move[1])
        
        # Kontrollera om agenten är utanför kartan
        if next_state not in states:
            reward = -10 # Straff för att gå in i väggen
            next_state = state # Stanna kvar
        else:
            reward = rewards[next_state]

        # Bellman-ekvationen i praktiken!
        old_value = q_table[state][action_key]
        next_max = max(q_table[next_state].values())
        
        new_value = old_value + learning_rate * (reward + discount_factor * next_max - old_value)
        q_table[state][action_key] = new_value
        
        state = next_state
        
        # Avsluta om agenten når ett slutmål
        if reward > 0 or reward < -40:
            done = True

    # Minska epsilon så att agenten utforskar mindre över tid
    epsilon *= epsilon_decay

# 5. Visa den inlärda policyn
print("--- Träning Klar! ---")
print("Optimal policy (bästa drag från varje ruta):")
policy = {}
for state, actions_map in q_table.items():
    policy[state] = max(actions_map, key=actions_map.get)

for row in range(3):
    row_str = ""
    for col in range(3):
        pos = (row, col)
        if pos == (1,1): row_str += " F "
        elif pos == (2,2): row_str += " O "
        else: row_str += f" {policy[pos]} "
    print(row_str)

När du kör koden kommer du se hur agenten, efter tusentals försök, har lärt sig den optimala vägen till osten. Den utskrivna policyn kommer tydligt att visa en "motorväg" av d (höger) och w (upp) som leder raka vägen till målet och undviker fällan. Detta är Bellman-ekvationen i praktiken, som skapar "brödsmulor" av höga Q-värden som agenten kan följa.

Dilemmat: Utforska eller Utnyttja? (Exploration vs. Exploitation)

I början av träningen står agenten inför ett kritiskt val. Ska den utnyttja (exploit) den kunskap den redan har och välja den handling som den tror är bäst? Eller ska den utforska (explore) genom att testa en slumpmässig handling, med chansen att hitta en ännu bättre väg? En bra agent börjar med att utforska mycket och övergår gradvis till att utnyttja sin kunskap mer.

Byggsten 4: Från Fuskblad till Generalist

Q-tabellen, vårt fuskblad för musen i labyrinten, har en fundamental svaghet: den kan inte hantera situationer den aldrig sett förut. Den är som en telefonkatalog. Om du vill ha numret till frisörsalongen på Storgatan 5 kan du slå upp exakt den kombinationen och hitta svaret. Men om du frågar "Vad är numret till frisörsalongen på en gata som liknar Storgatan?" har telefonkatalogen inget svar. Den kan inte generalisera.

För ett spel som Go, med fler möjliga brädpositioner än atomer i universum, är det omöjligt att skapa en telefonkatalog som täcker alla möjliga brädpositioner, alltså tillstånd, och de tillåtna handlingarna i varje tillstånd. Agenten kommer alltid att stöta på helt nya, unika situationer. Att memorera (Q-tabellen) är en återvändsgränd. Vi behöver en agent som kan resonera.

Här sker den stora revolutionen. Istället för en gigantisk telefonkatalog, ger vi agenten en "hjärna" som kan titta på en situation och uppskatta hur bra den är. Denna hjärna är ett neuralt nätverk.

Från att Slå Upp till att Uppskatta (Approximera)

Tänk dig skillnaden så här:

Q-tabellen (Telefonkatalogen): Lagrar ett exakt, inlärt värde för varje specifik situation den har upplevt. Den slår upp svaret.
Neurala Nätverket (Hjärnan): Lär sig de underliggande mönstren som gör en situation bra eller dålig. När den ser en helt ny brädposition, kan den titta på pjäsernas placering, maktbalansen och hoten, och sedan göra en kvalificerad gissning – en approximation – av hur värdefull situationen är. Den räknar ut en uppskattning.

Det är precis detta som menas med att nätverket "approximerar" Q-värdena. Det lagrar dem inte, det beräknar en rimlig uppskattning av dem i realtid, baserat på den generella kunskap den har byggt upp.

Varför "Djupt"?

För att kunna göra en bra uppskattning av en komplex situation som ett Go-parti, räcker det inte med ett enkelt neuralt nätverk. Experten måste kunna se mönster på flera olika nivåer, precis som vi diskuterade i det första kapitlet.

Ett grunt nätverk (med få lager) kanske bara kan se de mest grundläggande mönstren: "Jag har tre pjäser på rad."
Ett djupt nätverk (med många lager) kan bygga en hierarkisk förståelse:
- Lager 1: Ser enskilda pjäser.
- Lager 5: Kombinerar pjäser till formationer ("en stark försvarsmur").
- Lager 10: Känner igen strategiska koncept ("motståndaren försöker omringa mig på högerkanten").

Djupet gör att nätverket kan gå från att se pixlar på en skärm till att förstå den strategiska innebörden av vad som händer.

Deep Reinforcement Learning: Den nya superkraften

När vi kombinerar dessa två idéer – en agent som lär sig genom trial-and-error (Reinforcement Learning) och som använder ett djupt neuralt nätverk som sin "hjärna" (Deep Learning) – får vi Deep Reinforcement Learning (DRL).

Så här fungerar det i praktiken:

Input: Agenten tar in det nuvarande tillståndet (t.ex. en bild av Go-brädet) och matar in det i sitt djupa neurala nätverk.
Output: Nätverket fungerar nu som en "drag-utvärderare". För varje möjligt lagligt drag, spottar nätverket ur sig en siffra – dess uppskattning (approximation) av Q-värdet för just det draget.
Beslut: Agenten väljer det drag som nätverket gav högst poäng.
Inlärning: Efter att draget är gjort, ser agenten vad som händer. Den kanske vinner partiet några drag senare. Denna nya information används för att träna nätverket. Med Backpropagation skickas en signal tillbaka genom nätverket som säger: "Dina uppskattningar för de drag som ledde till denna vinst var för låga. Justera dina interna vikter så att du värderar liknande situationer högre i framtiden."

Det är denna kraftfulla kombination – förmågan att lära sig från erfarenhet och förmågan att generalisera till nya situationer – som gjorde AlphaGo och AlphaStar möjliga. Det löste problemet med de oändliga tillstånden och öppnade dörren för AI att bemästra uppgifter som tidigare ansetts vara omöjliga. Detaljer om AlphaGo och AlphaStar täcks i senare stycken.

Från Q-tabeller till Deep Q-Networks (DQN)

Q-tabellen har en fundamental svaghet: den kan inte hantera situationer den aldrig sett förut. Den är som en telefonkatalog; den kan bara slå upp exakta, memorerade värden. För ett spel som Go, med fler möjliga brädpositioner än atomer i universum, är detta en återvändsgränd. Vi behöver en agent som kan generalisera – som kan titta på en helt ny situation och göra en kvalificerad gissning om dess värde.

Här sker den stora revolutionen: istället för en gigantisk tabell, ger vi agenten ett djupt neuralt nätverk som sin "hjärna". Detta nätverk lär sig att approximera Q-värdena. Istället för att slå upp ett värde, tar nätverket in tillståndet (t.ex. en bild av spelbrädet) och räknar ut en uppskattning av Q-värdet för varje möjlig handling.

Men att träna ett neuralt nätverk med RL-data visade sig vara extremt instabilt. Två geniala innovationer från DeepMind var nödvändiga för att lösa detta:

Experience Replay: En RL-agent upplever världen som en korrelerad ström av händelser. Detta är dålig träningsdata för ett neuralt nätverk, som lär sig bäst från oberoende datapunkter. Lösningen är att agenten lagrar sina erfarenheter – (tillstånd, handling, belöning, nästa_tillstånd) – i en stor minnesbuffert. Under träningen väljer den sedan ut en slumpmässig minibatch av gamla erfarenheter att lära sig från. Detta bryter korrelationerna och gör träningen mycket stabilare.
Fixed Q-Targets (Målnätverk): Ett annat problem är att nätverket jagar ett rörligt mål. I Bellman-ekvationen används nätverket för att både förutsäga det nuvarande Q-värdet och målvärdet. Det är som att försöka träffa ett mål som flyttar sig varje gång du siktar. Lösningen är att använda två nätverk: ett huvudnätverk som ständigt lär sig, och ett "målnätverk" som är en fryst kopia av huvudnätverket. Målnätverket används för att beräkna målvärdet, och det uppdateras bara med jämna mellanrum. Detta ger en stabil och konsekvent måltavla för inlärningen.

Denna arkitektur – ett djupt neuralt nätverk tränat med Bellman-ekvationen, stabiliserat av Experience Replay och ett målnätverk – kallas ett Deep Q-Network (DQN) och var grunden för DeepMinds första stora genombrott när de lärde en AI att bemästra Atari-spel bara genom att titta på skärmen.

En Annan Väg: Policy Gradient-metoder

Q-learning och DQN är värdebaserade (value-based) metoder. Deras mål är att lära sig en funktion som korrekt uppskattar värdet av varje handling. Men det finns en helt annan familj av RL-algoritmer: policybaserade (policy-based) metoder.

Här är målet att lära sig en policy (π) direkt. Policyn är en funktion (oftast ett neuralt nätverk) som tar in ett tillstånd och direkt producerar en sannolikhetsfördelning över vilka handlingar som är bäst att ta. Istället för att först värdera alla handlingar och sedan välja den bästa, lär sig nätverket att direkt mappa ett tillstånd till en handling.

Analogi: Q-learning är som en matkritiker som noggrant lär sig att ge varje rätt på en meny ett exakt betyg från 1 till 100. För att välja mat, tittar du på listan och tar rätten med högst betyg. Policy Gradient är som en erfaren kock som, baserat på vilka råvaror som finns, direkt säger: "Gör den här rätten." Den hoppar över värderingssteget.

Inlärningen sker genom Policy Gradients. Om en agent utför en sekvens av handlingar som leder till en hög belöning, justeras nätverkets vikter så att sannolikheten för just de handlingarna ökar i liknande situationer i framtiden. Om en sekvens leder till en dålig belöning, minskas sannolikheten.

Actor-Critic: Det bästa av två världar

Moderna RL-system kombinerar ofta dessa två metoder i en Actor-Critic-arkitektur. Den består av två nätverk som arbetar tillsammans:

The Actor (Skådespelaren): Ett policy-nätverk som bestämmer vilken handling som ska tas.
The Critic (Kritikern): Ett värde-nätverk (likt ett Q-nätverk) som utvärderar hur bra handlingen som skådespelaren valde faktiskt var.

Kritikerns feedback används sedan för att uppdatera skådespelaren. Istället för att bara veta om en hel episod var "bra" eller "dålig", kan skådespelaren få omedelbar och nyanserad feedback: "Den handlingen du just tog i det här tillståndet var lite bättre än förväntat. Gör mer av det!" Detta gör inlärningen mycket effektivare och är grunden för många av de mest avancerade RL-agenterna idag.

Det psykologiska perspektivet: Den digitala Skinner-boxen

Denna process är en nästan perfekt digital implementation av behaviorism, en skola inom psykologin som blev känd genom B.F. Skinner. Skinner visade att han kunde lära råttor och duvor komplexa beteenden genom att belöna dem med matpellets när de utförde önskade handlingar. Hans berömda "Skinner-box" var en miljö designad för just detta.

På samma sätt är en RL-agent en digital råtta i en digital Skinner-box. Den har inget "förnuft" eller "förståelse" i mänsklig mening. Den är enbart driven av ett enda mål: att maximera sin belöningssignal. Detta enkla, men kraftfulla, koncept har visat sig vara otroligt effektivt för att lösa problem där det finns ett tydligt mål och tydliga regler.

Belöningens makt och fara

Allt en RL-agent gör, gör den för att maximera sin belöning. Detta är både dess styrka och dess svaghet. Om belöningsfunktionen är väl utformad kan den uppnå fantastiska resultat. Men om den är dåligt utformad kan det leda till helt oväntade och oönskade beteenden, ett problem som kallas reward hacking. En agent som belönas för att "plocka upp skräp" kan lära sig att det enklaste sättet att maximera belöningen är att välta en soptunna och sedan plocka upp samma skräp om och om igen.

Genombrottet: AlphaGo

Under lång tid var brädspelet Go en svår och krävande utmaning för AI-forskare. Schack hade besegrats av IBM:s Deep Blue redan 1997, men Go var en helt annan utmaning. Med sitt enkla bräde och få regler har Go fler möjliga spelpositioner än det finns atomer i det observerbara universumet. Den kombinatoriska explosionen var total. Att lösa Go med rå beräkningskraft var omöjligt. Det krävde något mer – en form av intuition.

År 2016 chockade DeepMind, ett brittiskt AI-företag, världen när deras program AlphaGo besegrade Lee Sedol, en av världens absolut bästa Go-spelare, med 4-1 i en match på fem partier.

AlphaGo var en sofistikerad hybrid. Den använde två djupa neurala nätverk som arbetade tillsammans, liknande en Actor-Critic-modell:

Ett Policy Network (Aktör): Tränat på miljontals mänskliga expertpartier för att lära sig föreslå lovande drag.
Ett Value Network (Kritiker): Tränat för att utvärdera en brädposition och förutsäga den troliga vinnaren.

Dess verkliga styrka kom från att den sedan spelade miljontals partier mot sig själv (reinforcement learning) för att upptäcka nya strategier bortom mänsklig kunskap.

Drag 37: Den kreativa maskinen?

Det mest berömda ögonblicket i matchen kom i det andra partiet. AlphaGo gjorde ett drag – drag 37 – som till en början fick mänskliga experter att klia sig i huvudet. Det ansågs vara ett misstag, ett närmast amatörmässigt drag som gick emot århundraden av mänsklig Go-visdom. Men draget visade sig vara genialt. Det var ett kreativt, oväntat och, som kommentatorerna uttryckte det, "vackert" drag som lade grunden för AlphaGos seger i partiet.

TODO Drag 37

En stiliserad bild av ett Go-bräde. De flesta stenarna är vita och svarta. En enda sten, "Drag 37", är markerad med en stark, glödande färg och en spotlight-effekt. Runt brädet syns silhuetter av förvånade åskådare. Bilden ska fånga det dramatiska och oväntade i ögonblicket.

Detta ögonblick tvingar fram en djup filosofisk fråga: Var draget genuint kreativt, eller var det bara ett statistiskt optimalt men mänskligt överraskande val från en maskin som utforskade möjligheter bortom vår fattningsförmåga? Om en handling inte har någon avsikt eller medvetenhet bakom sig, kan den då kallas kreativ? Samtidigt, om resultatet är både originellt och värdefullt, vad är det då om inte kreativitet?

Nästa nivå: Från brädspel till digitala världar

Efter den historiska segern i Go, ställde DeepMind in siktet på en ännu större utmaning: realtidsstrategispelet StarCraft II. Detta var ett gigantiskt kliv i komplexitet. Till skillnad från Go, som har perfekt information (båda spelarna ser hela brädet), spelas StarCraft II med ofullständig information (du vet inte vad din motståndare gör förrän du skickar ut enheter för att spana). Spelet sker i realtid, kräver långsiktig strategisk planering och snabba, precisa, taktiska beslut.

DeepMinds nya agent, AlphaStar, använde en ännu mer avancerad Actor-Critic-arkitektur. Den började med att imitera mänskliga expertspelare (övervakad inlärning). Därefter skapades en hel liga där olika versioner av AlphaStar fick tävla mot varandra dygnet runt i en accelererad, digital evolution (reinforcement learning). Agenterna spelade motsvarande 200 år av StarCraft-matcher varje dag.

Resultatet var en agent som inte bara kunde mäta sig med, utan fullständigt dominera de bästa professionella StarCraft II-spelarna i världen. AlphaStar visade att Reinforcement Learning inte var begränsat till turordningsbaserade brädspel. Principen om att lära sig genom trial-and-error, driven av en belöningssignal och styrd av sofistikerade Actor-Critic-arkitekturer, var tillräckligt kraftfull för att bemästra även de extremt komplexa, dynamiska och oförutsägbara miljöer som finns i moderna datorspel.

Perspektiv på Reinforcement Learning

Det biologiska & evolutionära perspektivet

Reinforcement Learning är kanske den AI-metod som har den starkaste kopplingen till biologin. Processen där en agent genom trial-and-error maximerar sin belöning är en form av snabbspolad, digital evolution. Agentens slumpmässiga försök är de genetiska mutationerna (variationen), och belöningsfunktionen är det naturliga urvalet som bestämmer vilka "beteenden" som överlever och förs vidare.

Det kroppsliga & fysiska perspektivet

Samtidigt belyser RL de enorma skillnaderna mellan digital och fysisk inlärning. Tänk på hur ett barn lär sig att gå. Det är också en process av trial-and-error. Men konsekvenserna av ett misstag är verkliga – barnet ramlar och slår sig. Denna smärta är en rik och omedelbar feedbacksignal. Barnet får också en enorm mängd sensorisk data från balanssinnet, trycket mot fotsulorna och synintryck.

En RL-agent i en simulation har inget av detta. Konsekvensen av ett misstag är bara en negativ siffra i en ekvation. Den fysiska världen, med sina lagar och risker, formar och begränsar vår inlärning på ett sätt som en simulation ännu inte kan replikera. Detta är en av de största anledningarna till att de mest imponerande RL-resultaten fortfarande sker i de digitala, väldefinierade miljöerna av spel och brädspel.

Case in Point: Hur Netflix väljer din miniatyrbild

Har du någonsin märkt att miniatyrbilden för en film på Netflix kan se annorlunda ut för dig än för din vän? Det är Reinforcement Learning i praktiken. Netflix använder en typ av RL-agent (specifikt en "multi-armed bandit") för att lösa ett enkelt men viktigt problem: Vilken av tio möjliga miniatyrbilder för filmen "Stranger Things" är mest sannolik att få dig att klicka?

Tillstånd: Din personliga visningshistorik (du gillar sci-fi, men inte skräck).
Handlingar: Visa miniatyrbild A (fokus på monstret), B (fokus på barnen), C (fokus på det mystiska labbet), etc.
Belöning: En +1 om du klickar och börjar titta, 0 om du ignorerar den.

Genom att ständigt utforska (visa en slumpmässig bild för en ny användare) och utnyttja (visa den bild som historiskt fungerat bäst för användare som liknar dig), lär sig systemet att personalisera marknadsföringen på en extremt detaljerad nivå. Det är ett perfekt exempel på hur RL används för att optimera ett specifikt affärsmål i en digital miljö.

Etiskt vägskäl: Reward Hacking och Sociala Medier

Problemet med reward hacking (när en agent hittar ett oväntat sätt att maximera sin belöning som går emot systemets avsikt) är inte bara ett tekniskt problem. Det är en perfekt metafor för hur algoritmerna i sociala medier fungerar.

En plattforms RL-agent har ett enkelt mål: maximera "engagemang" (din tid på sidan, antal klick, kommentarer). Agenten upptäcker snabbt att innehåll som väcker starka känslor – särskilt ilska och indignation – är extremt effektivt för att uppnå detta mål.

Agentens "lösning": Visa användaren mer och mer polariserande, upprörande och extremt innehåll, eftersom det är det som maximerar belöningssignalen (engagemang).
Den oavsiktliga konsekvensen: Agenten har "hackat" sin belöningsfunktion. Den har uppnått sitt mål, men på bekostnad av att skapa filterbubblor, öka samhällspolariseringen och potentiellt skada användarnas mentala hälsa.

Frågan: Om du var ingenjör på en social medieplattform, hur skulle du designa om belöningsfunktionen? Vilka mätvärden skulle du använda för att uppmuntra "hälsosamt" engagemang istället för bara "maximalt" engagemang, utan att samtidigt inskränka yttrandefriheten? Detta är en av de svåraste och viktigaste designfrågorna i vår tid.

Från digitalt till fysiskt

Ett hett forskningsområdena just nu är "Sim-to-Real". Idén är att först träna en robot i en säker och snabb simulering (där den kan krascha miljontals gånger utan kostnad) och sedan överföra den inlärda kunskapen till en verklig, fysisk robot. Att överbrygga klyftan mellan den rena simulationen och den stökiga verkligheten är en enorm utmaning.

Övningar

Reinforcement Learning

I detta kapitel kommer du att bygga vidare på den kod du sett i läroboken, analysera en mer avancerad agent, och sedan använda professionella verktyg för att lösa klassiska RL-problem.

Verktyg: Visual Studio Code med en Python-installation.

Förberedelser: Hämta Koden

Innan du börjar, kopiera kodexemplen för den text-baserade lekplatsen och Q-learning-agenten från läroboken till dina egna Python-filer. Du kommer att utgå från och modifiera dessa i den första övningen.

Övning 1: Anpassa och Utöka en Q-Learning Agent

Syfte: Att ta en fungerande Q-learning-implementation, anpassa den till en ny miljö och utöka den med en ny mekanik (stokastisk vind), för att fördjupa förståelsen för hur agenter hanterar osäkerhet.

Del 1: Anpassa för en Ny Miljö

Skapa en ny fil: my_rl_agent.py. Kopiera in koden för Q-learning-agenten från läroboken.
Definiera en ny, större värld: Din nya värld är ett 4x4-rutnät. Målet (G) är vid (3, 3) och det finns två fällor (F) vid (1, 3) och (2, 1).
```
S . . .  (S = Start at 0,0)
. . . F
. F . .
. . . G
```
Modifiera koden: Anpassa din q_learning_agent.py-fil. Du kommer behöva ändra rewards-dictionaryn och states-listan för att reflektera den nya 4x4-världen. Sätt belöningen för G till +100 och för F till -100.

Del 2: Introducera Osäkerhet (Stokastisk Vind)

Verkliga miljöer är sällan helt förutsägbara. Vi ska nu simulera detta med en "vind"-faktor.

Modifiera träningsloopen: Inuti while not done:-loopen i din träningskod, lägg till en ny mekanik. Efter att agenten har valt en handling (t.ex. d för höger), men innan du beräknar next_state, lägg till en liten slumpfaktor:

# ... inuti while-loopen ...
action_key = agent.choose_action(state) # Agenten väljer sin avsedda handling

# NY MEKANIK: Vind
wind_probability = 0.1 # 10% chans att vinden blåser
if random.uniform(0, 1) < wind_probability:
    # Vinden blåser! Välj en helt slumpmässig handling istället.
    action_key = random.choice(list(actions.keys()))
    print("Vinden blåste agenten ur kurs!")

# Fortsätt som vanligt med den (potentiellt nya) handlingen
move = actions[action_key]
next_state = (state[0] + move[0], state[1] + move[1])
# ... resten av loopen ...

Träna och Analysera: Kör din träningsloop igen med den nya vind-mekaniken.
- Titta på den slutgiltiga, utskrivna policyn. Har den optimala vägen förändrats jämfört med en vindstilla miljö?
- Hur tvingar osäkerheten i miljön agenten att hitta en mer "robust" policy, kanske en som håller sig längre bort från fällorna även om det innebär en längre väg?

Reflektera

Du har nu anpassat en agent till en ny miljö och introducerat osäkerhet. Detta är ett mycket mer realistiskt scenario.
Jämför Q-tabellen som genererats med och utan vind. Hur reflekterar Q-värdena den extra risken som vinden medför nära fällorna?

Övning 2: Anatomia av en Deep Q-Network (DQN)

Syfte: Att analysera en befintlig, fungerande DQN-agent för att förstå de nyckelkomponenter (Experience Replay, Target Network) som gör den stabil.

Del 1: Sätt upp miljön och koden

Installera bibliotek: Du behöver gymnasium för miljön och tensorflow för nätverket.
```
pip install gymnasium tensorflow
```

Skapa en fil: Skapa filen analyze_dqn.py och klistra in hela kodblocket nedan. Detta är en komplett, men förenklad, DQN-implementation.

import gymnasium as gym
import tensorflow as tf
from tensorflow.keras import layers
import numpy as np
import random
from collections import deque

# --- 1. REPLAY BUFFER ---
# Syfte: Lagra och slumpa agentens erfarenheter för att bryta korrelationer.
class ReplayBuffer:
    def __init__(self, capacity=10000):
        self.buffer = deque(maxlen=capacity)
    
    def add(self, state, action, reward, next_state, done):
        self.buffer.append((state, action, reward, next_state, done))
    
    def sample(self, batch_size):
        return random.sample(self.buffer, batch_size)
    
    def __len__(self):
        return len(self.buffer)

# --- 2. Q-NÄTVERKET ---
# Syfte: Skapa det neurala nätverk som ska approximera Q-funktionen.
def create_q_model(num_actions):
    model = tf.keras.Sequential([
        layers.Dense(64, activation='relu'),
        layers.Dense(64, activation='relu'),
        layers.Dense(num_actions, activation='linear')
    ])
    return model

# --- 3. HUVUDFUNKTION ---
def main():
    env = gym.make("CartPole-v1")
    num_actions = env.action_space.n
    
    # --- Två identiska nätverk skapas ---
    model = create_q_model(num_actions)
    model_target = create_q_model(num_actions)
    model_target.set_weights(model.get_weights()) # Kopiera vikterna

    optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
    replay_buffer = ReplayBuffer()
    
    # --- Hyperparametrar ---
    gamma = 0.99
    epsilon = 1.0
    epsilon_min = 0.01
    epsilon_decay = 0.995
    batch_size = 64
    update_target_freq = 10 # Hur ofta målnätverket ska uppdateras
    
    total_episodes = 200
    
    for episode in range(total_episodes):
        state, _ = env.reset()
        state = np.array([state])
        done = False
        total_reward = 0
        
        while not done:
            # --- Epsilon-greedy action selection ---
            if random.random() < epsilon:
                action = env.action_space.sample()
            else:
                q_values = model.predict(state, verbose=0)
                action = np.argmax(q_values[0])

            next_state, reward, done, _, _ = env.step(action)
            next_state = np.array([next_state])
            total_reward += reward
            
            # Lägg till erfarenheten i bufferten
            replay_buffer.add(state, action, reward, next_state, done)
            state = next_state

            # --- HJÄRTAT AV INLÄRNINGEN ---
            if len(replay_buffer) > batch_size:
                # 1. Hämta ett slumpmässigt minibatch
                minibatch = replay_buffer.sample(batch_size)
                
                states_sample, actions_sample, rewards_sample, next_states_sample, dones_sample = map(np.array, zip(*minibatch))
                
                # 2. Beräkna framtida Q-värde med MÅLNÄTVERKET
                future_q_values = model_target.predict(np.vstack(next_states_sample), verbose=0)
                target_q_values = rewards_sample + gamma * np.max(future_q_values, axis=1) * (1 - dones_sample)
                
                with tf.GradientTape() as tape:
                    # 3. Beräkna förlusten
                    q_values = model(np.vstack(states_sample))
                    action_masks = tf.one_hot(actions_sample, num_actions)
                    current_q_values = tf.reduce_sum(tf.multiply(q_values, action_masks), axis=1)
                    loss = tf.keras.losses.MSE(target_q_values, current_q_values)
                
                # 4. Backpropagation
                grads = tape.gradient(loss, model.trainable_variables)
                optimizer.apply_gradients(zip(grads, model.trainable_variables))

        # --- Uppdatera epsilon ---
        if epsilon > epsilon_min:
            epsilon *= epsilon_decay

        # --- Uppdatera målnätverket periodiskt ---
        if (episode + 1) % update_target_freq == 0:
            model_target.set_weights(model.get_weights())

        print(f"Episode {episode + 1}: Total Reward = {total_reward}, Epsilon = {epsilon:.2f}")

if __name__ == "__main__":
    main()

Del 2: Kodgranskning

Din uppgift är inte att skriva kod, utan att läsa och förstå. Gå igenom skriptet och hitta följande rader eller block. För varje punkt, skriv en kommentar i din egen kodfil som förklarar vad den gör.

Hitta Replay Buffer: Leta reda på klassen ReplayBuffer. Vad är syftet med add-metoden och sample-metoden?
Hitta Nätverken: Leta reda på funktionen create_q_model. Du kommer se att den anropas två gånger för att skapa model och model_target. Varför behövs två identiska nätverk?
Hitta Träningssteget: Inuti huvudloopen, hitta blocket som börjar med if len(replay_buffer) > batch_size:. Detta är hjärtat av inlärningen.
- Identifiera raden där ett slumpmässigt minibatch hämtas från replay_buffer.
- Identifiera raden där målnätverket (model_target) används för att beräkna det framtida Q-värdet.
- Identifiera raden där förlusten beräknas och tape.gradient() / optimizer.apply_gradients() anropas. Vad gör dessa rader?
Hitta Uppdateringen av Målnätverket: Leta efter raden model_target.set_weights(model.get_weights()). Hur ofta körs den (se variabeln update_target_freq)? Varför är det viktigt att den inte körs i varje steg?

Reflektera

Genom att ha analyserat denna kod har du nu en mycket djupare förståelse för de tekniska detaljer som krävs för att stabilisera DRL. Hur löser ReplayBuffer och model_target de problem som beskrivs i läroboken (korrelerad data och rörligt mål)?

Övning 3 (Bonus): Implementera en Policy Gradient Agent

Syfte: Att förstå den policy-baserade metoden genom att implementera en enkel REINFORCE-algoritm.

Denna övning är avancerad och rekommenderas för de som vill ha en djupare utmaning.

Skapa en fil: reinforce_agent.py.
Uppgift: Skriv ett Python-skript (med TensorFlow/Keras) som: a. Skapar en enkel policy-modell för CartPole-v1-miljön. Modellen ska ta in ett tillstånd och spotta ur sig en sannolikhetsfördelning för de möjliga handlingarna. b. Skriver en träningsloop där agenten spelar en hel episod och sparar alla tillstånd, valda handlingar och mottagna belöningar. c. Efter varje episod, beräkna den diskonterade avkastningen (discounted returns) för varje steg i episoden. d. Använd denna avkastning för att uppdatera modellens vikter. Handlingar som ledde till hög avkastning ska göras mer sannolika (och vice versa).

Behöver du hjälp?

Detta är en svår uppgift. Använd din AI-partner för att få en startpunkt. En bra prompt är: "Skriv ett exempel på en enkel REINFORCE-algoritm i Python med TensorFlow för att lösa CartPole-v1. Kommentera koden tydligt för att förklara hur policyn uppdateras baserat på den diskonterade avkastningen."

Övning 4: Jämför Metoder med Stable-Baselines3

Syfte: Att använda ett professionellt bibliotek för att träna och jämföra prestandan hos olika state-of-the-art RL-algoritmer.

Installera biblioteken: Stable-Baselines3 är ett standardbibliotek för RL.
```
pip install gymnasium stable-baselines3[extra]
```
Skapa en fil: compare_agents.py.
Uppgift: Skriv ett skript som: a. Importerar DQN (value-based) och PPO (policy-based) från stable_baselines3. b. Skapar CartPole-v1-miljön. c. Skapar och tränar en DQN-modell på miljön i 10 000 tidssteg. d. Skapar och tränar en PPO-modell på samma miljö i 10 000 tidssteg. e. Reflektera: När du kör model.learn() med verbose=1, skrivs statistik ut under träningen. Titta på kolumnen ep_rew_mean (genomsnittlig belöning per episod). Vilken av modellerna lär sig att balansera pinnen snabbast (når en hög, stabil belöning på färre tidssteg)? Detta visar hur olika metoder kan ha olika effektivitet på samma problem.

Övning 5: Belöningens Makt och Fara (Reward Hacking)

Syfte: Att praktiskt uppleva hur kritiskt utformningen av belöningsfunktionen är och hur agenter kan hitta oväntade "kryphål" (reward hacking) för att maximera sin belöning.

Modifiera din Miljö: Öppna din gridworld.py-fil.
Experiment 1: Ta bort straffet för att röra sig.
- Hitta raden i step-metoden som ger en liten negativ belöning för varje steg (t.ex. -0.1). Ändra detta värde till 0.
- Kör train.py igen. Titta på den nya Q-tabellen. Är vägen till målet fortfarande lika tydligt "upplyst" med höga värden, eller har agenten hittat mindre effektiva vägar som nu ser lika bra ut?
Experiment 2: Goodharts Lag i praktiken.
- Återställ steg-straffet. Ändra nu belöningsfunktionen drastiskt. Istället för att ge en stor belöning vid målet, ge en liten belöning (+0.5) för varje steg som tas i en ruta bredvid målet, men ingen belöning för att faktiskt nå målet.
- Träna om agenten. Vad lär den sig att göra? Kommer den att nå målet, eller har den hittat ett sätt att maximera sin poäng utan att uppfylla det egentliga syftet?.

Reflektera

"När ett mått blir ett mål, upphör det att vara ett bra mått." Hur är Experiment 2 ett perfekt exempel på denna princip (Goodharts Lag)?
Hur kan denna övning hjälpa oss att förstå de större utmaningarna med "The Alignment Problem" – att få avancerade AI-system att göra vad vi menar, inte bara vad vi bokstavligen säger åt dem att göra?

Övning 6: Från Labyrinter till Världsmästare (Diskussion)

Syfte: Att diskutera och reflektera över de filosofiska frågor som AlphaGos "drag 37" väckte.

Läs avsnittet om AlphaGo i läroboken igen. Titta gärna på ett klipp av draget på YouTube om du har möjlighet.
Diskutera följande frågor i en mindre grupp:
- Anser ni att AlphaGos drag 37 var genuint kreativt? Varför/varför inte?
- Försök att definiera vad "kreativitet" är. Måste en handling vara medveten eller avsiktlig för att kunna kallas kreativ?
- Om en AI kan skapa musik som berör oss, konst som fascinerar oss eller vetenskapliga hypoteser som ingen människa tänkt på – spelar det någon roll om den har en inre, medveten upplevelse av det den skapar?

Kärnkomponenterna: Agent, Miljö, Belöning​

Byggsten 1: Spelets Regler (Markov Decision Process)​

Markov-egenskapen: Schackbrädesprincipen​

Byggsten 2: Agentens Minne (Q-tabellen)​

Byggsten 3: Lärande genom Uppdatering (Bellman-ekvationen)​

Från Teori till Praktik: Q-learning i Python​

Steg 1: Bygg Intuition i en Text-baserad Lekplats​

Steg 2: Implementera Q-learning "From Scratch"​

Dilemmat: Utforska eller Utnyttja? (Exploration vs. Exploitation)​

Byggsten 4: Från Fuskblad till Generalist​

Från att Slå Upp till att Uppskatta (Approximera)​

Varför "Djupt"?​

Deep Reinforcement Learning: Den nya superkraften​

Från Q-tabeller till Deep Q-Networks (DQN)​

En Annan Väg: Policy Gradient-metoder​

Actor-Critic: Det bästa av två världar​

Det psykologiska perspektivet: Den digitala Skinner-boxen​

Genombrottet: AlphaGo​

Drag 37: Den kreativa maskinen?​

Nästa nivå: Från brädspel till digitala världar​

Perspektiv på Reinforcement Learning​

Det biologiska & evolutionära perspektivet​

Det kroppsliga & fysiska perspektivet​

Övningar​

Reinforcement Learning

Förberedelser: Hämta Koden​

Övning 1: Anpassa och Utöka en Q-Learning Agent​

Övning 2: Anatomia av en Deep Q-Network (DQN)​

Övning 3 (Bonus): Implementera en Policy Gradient Agent​

Övning 4: Jämför Metoder med Stable-Baselines3​

Övning 5: Belöningens Makt och Fara (Reward Hacking)​

Övning 6: Från Labyrinter till Världsmästare (Diskussion)​

Kärnkomponenterna: Agent, Miljö, Belöning

Byggsten 1: Spelets Regler (Markov Decision Process)

Markov-egenskapen: Schackbrädesprincipen

Byggsten 2: Agentens Minne (Q-tabellen)

Byggsten 3: Lärande genom Uppdatering (Bellman-ekvationen)

Från Teori till Praktik: Q-learning i Python

Steg 1: Bygg Intuition i en Text-baserad Lekplats

Steg 2: Implementera Q-learning "From Scratch"

Dilemmat: Utforska eller Utnyttja? (Exploration vs. Exploitation)

Byggsten 4: Från Fuskblad till Generalist

Från att Slå Upp till att Uppskatta (Approximera)

Varför "Djupt"?

Deep Reinforcement Learning: Den nya superkraften

Från Q-tabeller till Deep Q-Networks (DQN)

En Annan Väg: Policy Gradient-metoder

Actor-Critic: Det bästa av två världar

Det psykologiska perspektivet: Den digitala Skinner-boxen

Genombrottet: AlphaGo

Drag 37: Den kreativa maskinen?

Nästa nivå: Från brädspel till digitala världar

Perspektiv på Reinforcement Learning

Det biologiska & evolutionära perspektivet

Det kroppsliga & fysiska perspektivet

Övningar

Förberedelser: Hämta Koden

Övning 1: Anpassa och Utöka en Q-Learning Agent

Övning 2: Anatomia av en Deep Q-Network (DQN)

Övning 3 (Bonus): Implementera en Policy Gradient Agent

Övning 4: Jämför Metoder med Stable-Baselines3

Övning 5: Belöningens Makt och Fara (Reward Hacking)

Övning 6: Från Labyrinter till Världsmästare (Diskussion)