Göm menyn

729G78 Artificiell intelligens

Laboration 7: Artificiella neurala nät

Sammanfattning

I den här laborationen ska ni testa neurala nät som kan känna igen handskrivna siffror.

Syfte

Syftet med denna laboration är att ge ett konkret exempel på hur neurala nät fungerar och hur man kan tillämpa dem på mönsterigenkänning. Laborationen ger även möjlighet att använda och fördjupa den teori som förmedlas i föreläsningarna och i kursboken.

Om laborationen

För att laborationen ska gå så smidigt som möjligt, förbered er väl.

  1. Repetera materialet om neurala nät.
  2. Läs igenom de relevanta delarna av kursboken.
  3. Läs noggrant igenom labbinstruktionerna.

Materialet till denna laboration består av följande:

  • en implementation av en enkel nätarkitektur i Python
  • en datamängd för att träna och testa på

Den centrala filen är network.py som innehåller en implementation av en enkel nätverksarkitektur, skriven i Pythonbiblioteket PyTorch. Den definierar en klass Net som representerar feedforward-nät.

I denna laboration behöver ni inte modifiera nätverket med någon egen kod, men ni får gärna undersöka network.py och se om ni kan identifera element som tagits upp på föreläsningarna och i kurslitteraturen.

Datamängd

Den datamängd som används i laborationen kommer från MNIST-databasen av handskrivna siffror. Den är uppdelad i en träningsmängd (60 000 exempel) och en testmängd (10 000 exempel). Varje datapar består av en bild på en handskriven siffra och ett facit (siffran som bilden föreställer, guldstandarden). Här är några exempel på hur bilderna kan se ut:

Varje bild består av 28 x 28 = 784 pixlar som representerar nyanser av grått. För att kunna användas som indata till ett neuralt nät så transformeras varje bild till en vektor med 784 komponenter där varje komponent anger motsvarande pixelns gråvärde som ett flyttal mellan 0 och 1.

Här är exempel på träningsdata. Istället för bildvektorn visas själva bilden. Till höger om bilden visualiseras facitvektorn genom att rita ett svart sträck vars position i rutan motsvarar komponentens index. Sträcket ligger högst upp för siffran 0 och längst ner för siffran 9.

Exempelnätet

Exempelnätet har tre lager: ett indatalager, ett utdatalager och ett dolt lager. Indatalagret består av 784 neuroner (en för varje pixel i en bild), utdatalagret består av 10 neuroner (en för varje möjlig siffra).

Nedanstående rutor visualiserar exempel på nätets utdata när det matas med bildvektorer. Rutorna visar (från vänster till höger) bildvektorn, facitvektorn och vektorn med nätets utsignaler. I visualiseringen av utvektorn används gråvärden för att representera olika aktiveringsgrader i olika neuroner.

För att översätta en utvektor till en siffra tittar man på vilken komponent av vektorn som har det högsta gråvärdet. Om det är komponent 0 så tolkas vektorn som en representation av siffran 0, om det är komponent 1 så tolkas vektorn som en representation av siffran1, och så vidare. Om det finns flera komponenter med samma (högsta) gråvärde så ska den första användas för tolkningen.

Enligt denna tolkning så representerar alla ovanstående rutor fall där nätet har korrekt identifierat siffran. I nästan alla fall är faktiskt neuronen för guldstandardsiffran den enda neuronen som är aktiv. I exemplet med siffran 5 ser vi att två neuroner (5 och 6) konkurrerar med varandra; neuron 5 vinner. (Den har den största aktiveringen, dvs. kodar det största gråvärdet.)

Följande bilder visar fall där nätet inte lyckats att korrekt identifiera siffran: Den starkast aktiverade neuronen är inte den neuron som motsvarar guldstandardsiffran. Notera att nätets aktivitet är i många fall utspridd över flera neuroner på utlagret.

Köra exempelnätet

Filen network.py är konstruerad så att den kan ta in ett antal argument. De ni kommer laborera med är:
  • hidden-size: antal noder i det dolda lagret (default: 20)
  • lr: inlärningsparametern eta (learning rate) (default: 1.0)
  • epochs: antal epoker nätverket tränas: (default: 1)
  • För VG: run-vg: konstruerar ett nätverk utifrån den konfiguration som finns i filen network_config.py (det som anges i argumentet hidden-size kommer då skrivas över av den konfiguration som anges).

För att köra nätverket med defaultinställningarna (20 noder i dolda lagret, 1.0 learning rate, 1 epok) räcker det med att köra:

$ python3 network.py

Om man istället vill köra nätverket med 25 noder i dolda lagret, 0.1 som learning rate över 2 epoker blir kommandot:

$ python3 network.py --hidden-size 25 --lr 0.1 --epochs 2

För att köra nätverket med inställningarna för VG-uppgifterna körs network.py med argumentet --run-vg tillsammans med argumenten för att ändra inlärningsparameter och antal epoker.

Utförande

  1. Testa att koden fungerar genom att köra filen network.py från terminalen på följande sätt:
    $ python3 network.py --test-run
    (se till att ni laddat ner filerna och aktiverat rätt miljö genom Föreberedelser nedan). Detta kör ett test som försöker att ladda datamängderna och skickar en batch av träningsdata genom nätverket. Om allt går som det rapporterar kommandot lite information om nätverket följt av "Test succeeded, exiting".

  2. Gör uppgift 1.
  3. Varje körning av network.py tränar ett nätverk med de angivna inställningarna på träningsdatan, för att sedan utvärdera dess prestation på testdatan. Er uppgift är nu att experimentera med olika körningar av nätverket. Var tålmodiga, det kan ta några minuter att träna och testa nätet. Försök att förbättra nätets felkvot genom att:
    • variera antalet epoker
    • variera antalet noder i det dolda lagret
    • variera inlärningsparametern
    • variera alla dessa tre så kallade hyperparametrar tillsammans
    Undersök parametrarna ovan på ett strukturerat sätt och dokumentera era resultat. Fundera ordentligt över hur ni vill lägga upp experimenten eftersom varje körning kan ta några minuter. Defaultinställningarna kommer nog inte att fungera särskilt bra (ex. värdet på inlärningsparametern). När ni diskuterar era resultat, ange vilka inställningar ni använde.
  4. Gör upgifterna 3, 4 och 5.
  5. För VG: Gör uppgift 6. Modifiera nätverkets struktur i filen network_config.py och gör uppgift 7.

Föreberedelser

  1. Skapa en katalog för labben och navigera in i den från terminalen.
  2. Kopiera filerna från kurskatalogen:
    $ cp -r /courses/729G78/Lab7/* .
  3. Byt namn på och öppna dokumentet med uppgifter Lab7Exercises_LiU-ID-1_LiU-ID-2.odt för att matcha er grupp.
  4. Aktivera labbmiljön. OBS: Miljön måste aktiveras varje gång terminalen stängs.
    $ source /courses/729G78/labs/lab7-env/bin/activate

Arbeta på egen dator

  • Unix
    1. Skapa labbmiljön
      $ python3 -m venv /path/to/my/lab/environment
    2. Aktivera miljön
      $ source /path/to/my/lab/environment/bin/activate
    3. Kontrollera att miljön är aktiv (bör peka på miljön du skapade ovan)
      $ which python
    4. Installera nödvändiga bibliotek med pip
      $ pip install numpy torch
  • Windows Power Shell
    1. Skapa labbmiljön
      $ python -m venv /path/to/my/lab/environment
    2. Aktivera miljön
      $ /path/to/my/lab/environment/Scripts/Activate.ps1
      På Windows kan det vara nödvändigt att fixa ett rättighetsproblem under inställningar:
      $ Set-ExecutionPolicy Unrestricted -Scope Process
    3. Kontrollera att miljön är aktiv (bör peka på miljön du skapade ovan)
      $ pip -V
    4. Installera nödvändiga bibliotek med pip
      $ pip install numpy torch
  • Ladda ned och packa upp filerna: Lab7.zip
  • OBS: Miljön måste aktiveras varje gång terminalen stängs.

Inlämning

  1. Dokumentet med uppgifter som PDF.
  2. Ladda upp era filer i Lisam.

Krav för godkänt

För godkänt krävs att ni bearbetat alla uppgifter, och kunnat svara på relevanta frågor gällande era testresultat med kopplingar till terorin.

Krav för väl godkänt

För väl godkänt krävs att ni utvöver kraven ovan även bearbetat VG-uppgifterna. Dessutom krävs att svaren ni ger är utförliga, håller god kvalitet och har mycket tydliga kopplingar till teorin.


Sidansvarig: Robin Keskisärkkä