CMD + K

Introduksjon til maskinlæringKapittel 11Nevrale nettverk: fra perceptron til backpropagation

14 min lesing

Nevrale nettverk: fra perceptron til backpropagation

Start med perceptronet og XOR-problemet, se hvorfor deriverbare aktiveringer trengs, og følg gradientene bakover gjennom nettverket.

Læringsmål

01Regn ut outputen og én oppdatering for et perceptron med Heaviside-aktivering
02Forklar hvorfor Heaviside-steget ikke kan trenes med gradient descent, og hva sigmoid, tanh og ReLU endrer
03Vis hvorfor XOR ikke er lineært separabel, og forklar hvordan et skjult lag løser den
04Regn ut et forward pass og tell parametrene i et lite nett
05Bruk kjerneregelen til å regne ut gradienten for en vekt med backpropagation
06Forklar forsvinnende gradienter og hvorfor tapet i et nevralt nett er ikke-konvekst

0 av 19 aktiviteter

Kjerneidé

Et nevralt nettverk er mange små, enkle regnestykker koblet i lag: hvert nevron tar en vektet sum og sender den gjennom en bøyd funksjon. Ett nevron kan bare trekke én rett linje, men lag av nevroner kan bøye og brette rommet til nesten hvilken som helst form. Tenk på et samlebånd: ingen stasjon forstår hele produktet, og når produktet blir feil, sporer vi feilen bakover stasjon for stasjon. Det er backpropagation.

Steg 1 av 7

Perceptronet: vektet sum og terskel

Konsept

Byggesteinen er et nevron. Det vekter inputene, legger til en bias og får scoren ƒnevronets score:

z = w^{⊤} x + b = w_{1} x_{1} + \dots + w_{d} x_{d} + b

Vektene sier hvor mye hver input teller og i hvilken retning, og biasen flytter hvor lett nevronet slår til. Scoren sendes så gjennom en aktiveringsfunksjon $g$ , og outputen er $g (z)$ .

Det klassiske eksempelet er et perceptron. Det bruker en heaviside-funksjon som aktivering. Formelen ƒheaviside-funksjon er en trapp:

H (z) = {10 z \geq 0 z < 0

Outputen er altså en ren ja/nei-beslutning. Geometrisk er $w^{⊤} x + b = 0$ en rett linje, eller et hyperplan i flere dimensjoner, og perceptronet svarer 1 på den ene siden og 0 på den andre. Det er en lineær klassifikator, akkurat som logistisk regresjon, men med en hard terskel i stedet for en sannsynlighet.

Perceptronet lærer med ƒperceptronregelen: for hvert treningspunkt regner det ut $\overset{y}{^}$ og oppdaterer

w \leftarrow w + η (y - \overset{y}{^}) x, b \leftarrow b + η (y - \overset{y}{^})

Er svaret riktig, er $y - \overset{y}{^} = 0$ , og ingenting skjer. Svarte det 0 når fasiten var 1, dyttes vektene i retning av $x$ , slik at scoren for dette punktet øker neste gang. Kan dataene skilles av en rett linje, finner regelen en slik linje etter et endelig antall oppdateringer. Kan de ikke det, slutter den aldri å flytte seg.

Interaktiv figur

Prøv: Gå gjennom ett punkt om gangen: se hva perceptronet svarer, hvor stor feilen er og hvordan vektene og linja flytter seg. Fortsett til alle fire er riktige.

Trinn 1 av 4 · Velg punktVi lærer av ett punkt om gangen. AND-punktet (0, 1) er feil klassifisert, så vi tar det: x₁ = 0 og x₂ = 1.

Riktige2 av 4Feil på2 punkter

Vekt w₁1,00Vekt w₂1,00Bias b−0,50

Forklar hvert trinn

Vis utregning

Sannhetstabell for AND med nettets utdata
x₁	x₂	z = w₁x₁ + w₂x₂ + b	ŷ = H(z)	y (AND)	Riktig
0	0	−0,50	0	0	riktig
0	1	0,50	1	0	feil
1	0	0,50	1	0	feil
1	1	1,50	1	1	riktig

Laster interaktiv figur …

Figur 11.1Perceptronet lærer AND. Startvektene gir OR, ikke AND; i det fargede området svarer perceptronet 1.

Interaktiv

RegneeksempelVis at

w = (1, 1)

b = - 1, 5

gir AND, og gjør én perceptronoppdatering fra

w = (1, 1)

b = - 0, 5

med

η = 0, 5

.Vis løsning

Steg 1. Med $b = - 1, 5$ gir $(0, 0)$ scoren $- 1, 5$ , $(0, 1)$ og $(1, 0)$ gir $- 0, 5$ , og $(1, 1)$ gir $0, 5$ . Heaviside gir $0, 0, 0, 1$ , som er AND.

Steg 2. Med $b = - 0, 5$ gir $(1, 0)$ scoren $z = 0, 5 \geq 0$ , så $\overset{y}{^} = 1$ , men fasiten for AND er $0$ . Feilen er $y - \overset{y}{^} = - 1$ .

Steg 3. Oppdatering: $w \leftarrow (1, 1) + 0, 5 \cdot (- 1) \cdot (1, 0) = (0, 5; 1)$ og $b \leftarrow - 0, 5 + 0, 5 \cdot (- 1) = - 1$ .

Steg 4. Nå gir $(1, 0)$ scoren $0, 5 - 1 = - 0, 5 < 0$ , altså riktig svar $0$ . Men $(0, 1)$ gir $1 - 1 = 0 \geq 0$ og dermed feil svar $1$ . Regelen fortsetter med neste feil til alle fire punktene er riktige.

Øving 1 av 2Tallsvar

Et perceptron har $w = (0, 5; - 0, 5)$ , $b = 0$ og læringsrate $η = 0, 2$ . Det predikerer $\overset{y}{^} = 1$ hvis $z = w^{⊤} x + b \geq 0$ og ellers $0$ . Det får treningspunktet $x = (1, 2)$ med fasit $y = 1$ . Gjør én oppdatering med perceptronregelen. Hva blir scoren $z$ for det samme punktet etter oppdateringen? Oppgi svaret med én desimal.

Øving 2 av 2Kode · Python

Ett perceptronsteg

Gjør ett steg med perceptronregelen for etiketter $y \in {0, 1}$ . Perceptronet predikerer $\overset{y}{^} = 1$ hvis $w \cdot x + b \geq 0$ og $\overset{y}{^} = 0$ ellers, og oppdaterer så

$w \leftarrow w + η (y - \overset{y}{^}) x, b \leftarrow b + η (y - \overset{y}{^})$

Signatur: perceptron_steg(w, b, eta, x, y) returnerer (y_hat, w_ny, b_ny).

Inndata: $w$ på første linje, $b$ og $η$ på andre, $x$ på tredje og $y$ på fjerde.

Utdata: $\overset{y}{^}$ på første linje og de nye vektene etterfulgt av ny $b$ på andre, med fire desimaler. Koden under den låste linjen leser inndata og skriver utdata, så du fyller bare inn funksjonen.

Eksempel

Inndata:
1 -1
0 0.5
1 3
1

Utdata:
0
1.5000 0.5000 0.5000

Utregning: $w \cdot x + b = 1 - 3 + 0 = - 2 < 0$ , så $\overset{y}{^} = 0$ og $y - \overset{y}{^} = 1$ . Da blir $w = (1, - 1) + 0, 5 \cdot (1, 3) = (1, 5; 0, 5)$ og $b = 0 + 0, 5 = 0, 5$ .

Pythonlosning.py

"""Ett steg med perceptronregelen for etiketter 0/1."""


def perceptron_steg(w, b, eta, x, y):
    # TODO: prediker y_hat = 1 hvis w·x + b >= 0, ellers 0, og oppdater
    # w og b med perceptronregelen
    return 0, list(w), b


# --- ikke endre under denne linjen ---
def fmt(v, d=4):
    s = f"{v:.{d}f}"
    return s[1:] if s.startswith("-") and float(s) == 0 else s


w = [float(t) for t in input().split()]
b, eta = (float(t) for t in input().split())
x = [float(t) for t in input().split()]
y = int(input())
y_hat, w_ny, b_ny = perceptron_steg(w, b, eta, x, y)
print(y_hat)
print(" ".join(fmt(v) for v in w_ny + [b_ny]))

Testtilfeller3 tester kjøres ved «Sjekk»

Steg 2 av 7

Heaviside-steget gir ingen gradient

Konsept

Perceptronregelen fungerer for ett nevron, men den sier ingenting om hvordan vi skal justere vektene i et nett med flere lag. Da trenger vi gradient descent fra kapittel 3: regn ut hvordan tapet endrer seg når hver vekt endres litt, og gå motsatt vei. Det krever deriverte gjennom aktiveringen, og der stopper Heaviside-funksjonen opp.

Den deriverte av $H (z)$ er 0 for alle $z \neq = 0$ , fordi funksjonen er flat på begge sider av steget. I $z = 0$ hopper den, og der finnes ingen derivert. En liten endring i en vekt endrer derfor nesten aldri outputen, og når den først gjør det, skjer det som et hopp. Gradienten sier at ingen retning er bedre enn en annen, og gradient descent står bom stille. Heaviside er ubrukelig for gradientbasert læring.

Løsningen er å bytte ut trappen med en glatt, deriverbar funksjon:

ƒSigmoidaktivering, $σ (z) = 1/ (1 + e^{- z})$ , er en myk versjon av steget med output i $(0, 1)$ . ƒSigmoid-derivert er $σ (z) (1 - σ (z))$ , som er størst i $z = 0$ , der den er $0, 25$ .
$tanh (z)$ har samme S-form, men output i $(- 1, 1)$ og er sentrert i 0. Den deriverte er $1 - tanh^{2} (z)$ , som er høyst 1.
ƒReLU, $ReLU (z) = max (0, z)$ , er 0 for negative scorer og lik $z$ for positive. Den deriverte er 0 eller 1, og i $z = 0$ velger implementasjonen bare en verdi.

Interaktiv figur

ReLU har også derivert 0 for negative scorer, men for positive scorer slipper den gradienten gjennom uendret. Så lenge et nevron er aktivt for noen av inputene, lærer det. Sigmoid gir alltid litt gradient, men svært lite når $∣ z ∣$ er stor. Da sier vi at nevronet er mettet.

Prøv: Bytt mellom aktiveringene og dra z: hvor er den deriverte ulik null, og hvor er σ′ størst?

H(2)1H′0Trenbar med GDnei

Input z2,0

Vis utregning

Heaviside: H(z) = 1 for z ≥ 0, ellers 0
Derivert: 0 for z ≠ 0, udefinert i z = 0; i z = 2,0: flat på begge sider av spranget
Trenbar med gradient descent?: H′ = 0 overalt (udefinert i 0): en liten vektendring endrer ikke tapet, så gradient descent får ingen retning å gå i.

Laster interaktiv figur …

Figur 11.2Hvilke aktiveringer gir en gradient å følge? Fire aktiveringer med deriverte stiplet; Heaviside har derivert 0 overalt og ingen i z = 0.

Interaktiv

RegneeksempelRegn ut

σ (z)

σ^{'} (z)

for

z = 0

z = 3

, og sammenlign med ReLU og Heaviside.Vis løsning

Steg 1. $z = 0$ : $σ (0) = \frac{1}{2}$ , så $σ^{'} (0) = \frac{1}{2} \cdot \frac{1}{2} = \frac{1}{4}$ .

Steg 2. $z = 3$ : $e^{- 3} \approx 0, 0498$ , så $σ (3) = 1/1, 0498 \approx 0, 953$ og $σ^{'} (3) \approx 0, 953 \cdot 0, 047 \approx 0, 045$ . Sigmoid er nesten flat her.

Steg 3. ReLU har derivert $1$ i $z = 3$ og $0$ for alle $z < 0$ . Heaviside har derivert $0$ i $z = 3$ og ingen derivert i $z = 0$ .

Steg 4. Sigmoid gir altså alltid litt gradient, men lite når scoren er stor. ReLU gir full gradient for positive scorer. Heaviside gir aldri noe å gå etter.

Øving 1 av 3Flervalg

Hva er $ReLU (- 2)$ ?

Øving 2 av 3Flervalg

Et perceptron bruker Heaviside-aktivering ( $1$ hvis $z \geq 0$ , ellers $0$ ). Hvorfor kan vi ikke trene et flerlagsnett med denne aktiveringen med gradient descent?

Øving 3 av 3Tallsvar

Regn ut den deriverte av sigmoid, $σ^{'} (z) = σ (z) (1 - σ (z))$ , i $z = - 1$ . Oppgi svaret med tre desimaler.

Steg 3 av 7

XOR: når én rett linje ikke holder

Konsept

Siden perceptronet trekker én rett linje, krever det lineær separerbarhet: det må finnes en linje med alle 1-erne på den ene siden og alle 0-erne på den andre. AND og OR oppfyller dette. XOR gjør det ikke. XOR er 1 når nøyaktig én av inputene er 1. De to 1-erne, $(0, 1)$ og $(1, 0)$ , ligger på den ene diagonalen i enhetskvadratet, og de to 0-erne, $(0, 0)$ og $(1, 1)$ , ligger på den andre. Prøv å tegne én rett linje som skiller dem. Det går ikke.

Det kan også vises med fire ulikheter. For å få 0 på $(0, 0)$ trengs $b < 0$ . For å få 1 på $(1, 0)$ og $(0, 1)$ trengs $w_{1} + b \geq 0$ og $w_{2} + b \geq 0$ . Legger vi sammen de to, får vi $w_{1} + w_{2} + 2 b \geq 0$ , altså $w_{1} + w_{2} + b \geq - b > 0$ . Men da svarer perceptronet 1 på $(1, 1)$ , der fasiten er 0. Ingen vekter oppfyller alle fire kravene.

Løsningen er et skjult lag mellom input og output. To skjulte nevroner kan trekke to linjer: ett som svarer «minst én er 1» (OR), og ett som svarer «ikke begge er 1» (NAND). XOR er nøyaktig de punktene der begge svarer ja, så outputnevronet trenger bare å være en AND av de to. Det skjulte laget gjør om inputene til en ny representasjon der problemet blir lineært separabelt. Det er hele ideen bak dype nett: tidlige lag lager nye features som senere lag kan skille med enkle grenser, og nettet lærer disse featurene selv.

Vanlig felleFlere lag uten aktivering hjelper ikke

To lineære lag etter hverandre er fortsatt lineære: $W_{2} (W_{1} x + b_{1}) + b_{2} = (W_{2} W_{1}) x + (W_{2} b_{1} + b_{2})$ . Uten en ikke-lineær aktivering mellom lagene kollapser hele nettet til én rett linje, og XOR er like uløselig som før.

Interaktiv figur

Prøv: Gå gjennom noen oppdateringer og se at minst ett punkt alltid blir feil; slå så på Skjult lag og se de to linjene skille klassene.

Trinn 1 av 4 · Velg punktVi lærer av ett punkt om gangen. XOR-punktet (1, 1) er feil klassifisert, så vi tar det: x₁ = 1 og x₂ = 1.

Riktige3 av 4Feil på1 punktLineært separabelnei

Vekt w₁1,00Vekt w₂1,00Bias b−0,50

Forklar hvert trinn

Vis utregning

Sannhetstabell for XOR med nettets utdata
x₁	x₂	z = w₁x₁ + w₂x₂ + b	ŷ = H(z)	y (XOR)	Riktig
0	0	−0,50	0	0	riktig
0	1	0,50	1	1	riktig
1	0	0,50	1	1	riktig
1	1	1,50	1	0	feil

Laster interaktiv figur …

Figur 11.3XOR trenger et skjult lag. Ingen enkelt linje skiller XOR; to skjulte nevroner gir to linjer og et bånd i midten.

Interaktiv

Konsept

Figuren bruker AND i stedet for NAND i det andre skjulte nevronet, og outputen svarer da «OR, men ikke AND». Linjene er de samme som i eksempelet under.

RegneeksempelVis at et nett med to skjulte Heaviside-nevroner løser XOR.Vis løsning

Steg 1. Velg $h_{1} = H (x_{1} + x_{2} - 0, 5)$ som er OR, $h_{2} = H (- x_{1} - x_{2} + 1, 5)$ som er NAND, og output $\overset{y}{^} = H (h_{1} + h_{2} - 1, 5)$ som er AND.

Steg 2. $(0, 0)$ : $h_{1} = H (- 0, 5) = 0$ , $h_{2} = H (1, 5) = 1$ og $\overset{y}{^} = H (- 0, 5) = 0$ .

Steg 3. $(0, 1)$ og $(1, 0)$ : $h_{1} = H (0, 5) = 1$ , $h_{2} = H (0, 5) = 1$ og $\overset{y}{^} = H (0, 5) = 1$ .

Steg 4. $(1, 1)$ : $h_{1} = H (1, 5) = 1$ , $h_{2} = H (- 0, 5) = 0$ og $\overset{y}{^} = H (- 0, 5) = 0$ .

Steg 5. Outputen er $0, 1, 1, 0$ , som er XOR. I det skjulte rommet $(h_{1}, h_{2})$ havner de to 1-erne i samme punkt $(1, 1)$ , og der holder én linje.

Øving 1 av 2Flervalg

Hvorfor trenger et flerlagsnett vanligvis ikke-lineære aktiveringsfunksjoner?

Øving 2 av 2Flervalg

Hvorfor kan ett enkelt perceptron ikke lære XOR-funksjonen på inputene $(0, 0), (0, 1), (1, 0), (1, 1)$ ?

Steg 4 av 7

Forward pass: regn et lite nett

Konsept

Et nett med flere lag regnes ut fra venstre mot høyre. Det kalles et forward pass. Hvert lag gjør det samme som ett nevron, bare for mange nevroner samtidig, med ƒforward pass i et lag:

a^{(ℓ)} = g (W^{(ℓ)} a^{(ℓ - 1)} + b^{(ℓ)}), a^{(0)} = x

Rad $j$ i vektmatrisen $W^{(ℓ)}$ inneholder vektene inn til nevron $j$ i laget. Har forrige lag $n_{ℓ - 1}$ nevroner og dette laget $n_{ℓ}$ , har $W^{(ℓ)}$ formen $n_{ℓ} \times n_{ℓ - 1}$ og $b^{(ℓ)}$ lengden $n_{ℓ}$ . Formelen ƒparametre i et lag teller dermed $n_{ℓ - 1} n_{ℓ}$ vekter pluss $n_{ℓ}$ biaser for laget, og summen over alle lag er antallet vekter og biaser treningen må lære.

Outputlaget velges etter oppgaven. Binær klassifikasjon bruker ett sigmoid-nevron, som gir $P (y = 1 ∣ x)$ . For $K$ gjensidig utelukkende klasser brukes ƒsoftmax, som gjør $K$ scorer om til sannsynligheter som summerer til 1. Regresjon bruker ofte ingen aktivering i outputlaget.

Rekkefølgen i hvert lag er alltid den samme: vektet sum, legg til bias, så aktivering. Neste lag får aktiveringen $a$ , ikke scoren $z$ . Å sende videre $z$ i stedet for $a$ er den vanligste regnefeilen.

Figur 11.4Forward pass: vektene står på kantene, og h₂ er død

Playground

Koden regner ut nettet i figuren.

Forward pass i et lite nettverk

Prøv: Dra x1 og x2 (prøv (1, 1)) og se hvilke nevroner som blir igjen i «aktive nevroner» etter ReLU, og hvordan «p» endrer seg.

x12.0x2-1.0

Pythonkap7-forward-pass.py

import numpy as np

x1 = 2.0  # @param -2..2 0.5
x2 = -1.0  # @param -2..2 0.5
x = np.array([x1, x2])                       # input
W1 = np.array([[1.0, 0.5],                   # rad j = vektene inn til nevron j
               [-1.0, 0.5],
               [0.5, -1.0]])
b1 = np.array([-1.0, 0.5, 0.0])
w2 = np.array([1.2, -0.7, 0.4])              # vekter inn til output
b2 = -1.0

z1 = W1 @ x + b1                             # skjult score
h = np.maximum(0, z1)                        # ReLU
z2 = w2 @ h + b2                             # output-score
p = 1 / (1 + np.exp(-z2))                    # sigmoid

print(f"z1 = {z1}   h = {h}   aktive nevroner: {np.flatnonzero(h > 0).tolist()}")
print(f"z2 = {z2:.2f}   p = {p:.4f}")
print(f"parametre: {W1.size + b1.size + w2.size + 1}")

Ctrl/Cmd + Enter kjører

RegneeksempelRegn forward pass for nettet i figuren med input

x = (2, - 1)

.Vis løsning

Vektene er

W^{(1)} = 1 - 1 0, 5 0, 5 0, 5 - 1, b^{(1)} = - 1 0, 5 0, w^{(2)} = (1, 2; - 0, 7; 0, 4), b^{(2)} = - 1

Steg 1. Skjulte scorer, rad for rad: $z_{1} = 2 - 0, 5 - 1 = 0, 5$ , $z_{2} = - 2 - 0, 5 + 0, 5 = - 2$ og $z_{3} = 1 + 1 + 0 = 2$ .

Steg 2. ReLU: $h = (0, 5; 0; 2)$ . Nevron 2 har negativ score og sender ingenting videre for denne inputen.

Steg 3. Outputscore: $z = 1, 2 \cdot 0, 5 - 0, 7 \cdot 0 + 0, 4 \cdot 2 - 1 = 0, 6 + 0, 8 - 1 = 0, 4$ .

Steg 4. Sigmoid: $\overset{p}{^} = σ (0, 4) = 1/ (1 + e^{- 0, 4}) \approx 1/1, 670 \approx 0, 599$ .

Steg 5. Parametre: det skjulte laget har $2 \cdot 3 + 3 = 9$ og outputlaget $3 \cdot 1 + 1 = 4$ , til sammen $13$ .

Øving 1 av 3Flervalg

Et lite nett har input $x = (1, 2)$ og to skjulte ReLU-nevroner med $z_{1} = x_{1} - x_{2}$ og $z_{2} = 2 x_{1} + x_{2} - 1$ . Outputen er $\overset{y}{^} = 3 h_{1} + h_{2}$ . Hva er $\overset{y}{^}$ ?

Øving 2 av 3Tallsvar

Et fullt koblet nett har 4 input, ett skjult lag med 6 nevroner og et outputlag med 3 nevroner. Hvor mange trenbare parametre, vekter og biaser, har nettet?

Øving 3 av 3Kode · Python

Forward pass i et 2–2–1-nett

Nettet har to innganger, et skjult lag med to nevroner og ett utgangsnevron, alle med sigmoid. Implementer forward pass:

$h = σ (W_{1} x + b_{1}), \overset{y}{^} = σ (w_{2} \cdot h + b_{2})$

der rad $j$ i $W_{1}$ inneholder vektene inn til skjult nevron $j$ . Funksjonen sigmoid er gitt.

Signatur: forover(x, W1, b1, w2, b2) returnerer (h, y_hat), der h er lista med de to skjulte aktiveringene.

Inndata: seks linjer med $x$ , de to radene i $W_{1}$ , $b_{1}$ , $w_{2}$ og $b_{2}$ .

Utdata: de skjulte aktiveringene på første linje og $\overset{y}{^}$ på andre, med fire desimaler. Koden under den låste linjen leser inndata og skriver utdata, så du fyller bare inn funksjonen.

Eksempel

Inndata:
1 1
1 -1
0.5 0.5
0 -1
2 -2
0

Utdata:
0.5000 0.5000
0.5000

Utregning: Begge skjulte summer er 0: $1 - 1 + 0 = 0$ og $0, 5 + 0, 5 - 1 = 0$ , så $h = (0, 5; 0, 5)$ . Utgangssummen er $2 \cdot 0, 5 - 2 \cdot 0, 5 + 0 = 0$ , og $\overset{y}{^} = σ (0) = 0, 5$ .

Pythonlosning.py

"""Forward pass i et 2-2-1-nett med sigmoid i alle nevroner."""
import math


def sigmoid(z):
    return 1 / (1 + math.exp(-z))


def forover(x, W1, b1, w2, b2):
    # TODO: skjult lag h = sigmoid(W1 x + b1), utgang y_hat = sigmoid(w2 · h + b2)
    return [0.0, 0.0], 0.0


# --- ikke endre under denne linjen ---
def fmt(v, d=4):
    s = f"{v:.{d}f}"
    return s[1:] if s.startswith("-") and float(s) == 0 else s


x = [float(t) for t in input().split()]
W1 = [[float(t) for t in input().split()] for _ in range(2)]
b1 = [float(t) for t in input().split()]
w2 = [float(t) for t in input().split()]
b2 = float(input())
h, y_hat = forover(x, W1, b1, w2, b2)
print(" ".join(fmt(v) for v in h))
print(fmt(y_hat))

Testtilfeller3 tester kjøres ved «Sjekk»

Steg 5 av 7

Backpropagation: kjerneregelen baklengs

Konsept

Etter et forward pass har vi et tap $J$ . For å ta et gradient descent-steg trenger vi $\partial J / \partial w$ for hver eneste vekt. Backpropagation er måten å regne ut alle disse effektivt på. Det er verken en egen læringsalgoritme eller et eget tap, bare ƒkjerneregel brukt systematisk bakover gjennom nettet.

En vekt påvirker tapet bare gjennom en kjede av mellomverdier. Vekten $w$ endrer scoren $z$ , scoren endrer aktiveringen $a$ , aktiveringen endrer neste lag, og til slutt endres tapet. Kjerneregelen sier at den totale effekten er produktet av de lokale effektene langs kjeden:

\frac{\partial J}{\partial w} = \frac{\partial J}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w}

Hvert ledd er enkelt. $\partial z / \partial w$ er inputen til vekten, $\partial a / \partial z$ er den deriverte av aktiveringen, og $\partial J / \partial a$ har vi allerede regnet ut for laget etter. Backprop starter derfor ved tapet og jobber seg bakover lag for lag, og gjenbruker hver mellomverdi i stedet for å regne hele kjeden på nytt for hver vekt. Påvirker en aktivering flere nevroner i neste lag, summeres bidragene.

Noen snarveier er nyttige. Med sigmoid-output og binær kryssentropi blir $\partial J / \partial z = \overset{p}{^} - y$ i outputnevronet. Med kvadratisk tap $J = \frac{1}{2} (\overset{y}{^} - y)^{2}$ er $\partial J / \partial \overset{y}{^} = \overset{y}{^} - y$ . Gjennom ReLU passerer gradienten uendret når $z > 0$ og stoppes når $z < 0$ .

Når gradientene er kjent, oppdateres vektene med ƒvektoppdatering. Backprop regner ut gradienten, og gradient descent bruker den.

Figur 11.5Backprop gjenbruker lokale deriverte lag for lag

Playground

Forward og ett backprop-steg i NumPy

Prøv: Bytt fasit med y og se «dL/dz2» og gradientene skifte fortegn, mens «tap før» → «etter» fortsatt synker.

Pythonkap7-ett-treningssteg.py

import numpy as np

sig = lambda z: 1 / (1 + np.exp(-z))
x = np.array([1.0, 0.5])                     # ett treningseksempel med fasit y
y = 1  # @param 0..1
W1 = np.array([[0.4, -0.6], [0.3, 0.8]]); b1 = np.zeros(2)
w2 = np.array([0.7, -0.5]); b2 = 0.0
eta = 0.5                                    # læringsrate

def forover(W1, b1, w2, b2):
    h = sig(W1 @ x + b1)                     # skjult lag (sigmoid)
    p = sig(w2 @ h + b2)                     # output (sigmoid)
    return -(y * np.log(p) + (1 - y) * np.log(1 - p)), h, p

L, h, p = forover(W1, b1, w2, b2)
dz2 = p - y                                  # bakover med kjerneregelen: dL/dz2 (sigmoid + BCE)
dw2, db2 = dz2 * h, dz2
dz1 = dz2 * w2 * h * (1 - h)                 # dL/dh · dh/dz1
dW1, db1 = np.outer(dz1, x), dz1

e = 1e-6; W1e = W1.copy(); W1e[0, 0] += e    # numerisk kontroll av én vekt
print(f"p = {p:.3f}, dL/dz2 = {dz2:+.3f}")
print(f"dL/dW1[0,0]: backprop {dW1[0, 0]:+.5f}, numerisk {(forover(W1e, b1, w2, b2)[0] - L) / e:+.5f}")
L2 = forover(W1 - eta * dW1, b1 - eta * db1, w2 - eta * dw2, b2 - eta * db2)[0]
print(f"tap før {L:.4f}, etter ett steg {L2:.4f}")

import numpy as np

sig = lambda z: 1 / (1 + np.exp(-z))
x = np.array([1.0, 0.5])                     # ett treningseksempel med fasit y
y = 1  # @param 0..1
W1 = np.array([[0.4, -0.6], [0.3, 0.8]]); b1 = np.zeros(2)
w2 = np.array([0.7, -0.5]); b2 = 0.0
eta = 0.5                                    # læringsrate

def forover(W1, b1, w2, b2):
    h = sig(W1 @ x + b1)                     # skjult lag (sigmoid)
    p = sig(w2 @ h + b2)                     # output (sigmoid)
    return -(y * np.log(p) + (1 - y) * np.log(1 - p)), h, p

L, h, p = forover(W1, b1, w2, b2)
dz2 = p - y                                  # bakover med kjerneregelen: dL/dz2 (sigmoid + BCE)
dw2, db2 = dz2 * h, dz2
dz1 = dz2 * w2 * h * (1 - h)                 # dL/dh · dh/dz1
dW1, db1 = np.outer(dz1, x), dz1

e = 1e-6; W1e = W1.copy(); W1e[0, 0] += e    # numerisk kontroll av én vekt
print(f"p = {p:.3f}, dL/dz2 = {dz2:+.3f}")
print(f"dL/dW1[0,0]: backprop {dW1[0, 0]:+.5f}, numerisk {(forover(W1e, b1, w2, b2)[0] - L) / e:+.5f}")
L2 = forover(W1 - eta * dW1, b1 - eta * db1, w2 - eta * dw2, b2 - eta * db2)[0]
print(f"tap før {L:.4f}, etter ett steg {L2:.4f}")

Ctrl/Cmd + Enter kjører

RegneeksempelEt minimalt nett har

\overset{y}{^} = w_{2} \cdot ReLU (w_{1} x)

og tapet

J = \frac{1}{2} (\overset{y}{^} - y)^{2}

. Med

x = 1

y = 2

w_{1} = 0, 5

w_{2} = 2

η = 0, 1

: regn ut gradientene og gjør ett steg.Vis løsning

Steg 1. Forward: $z = 0, 5 \cdot 1 = 0, 5$ , $h = ReLU (0, 5) = 0, 5$ , $\overset{y}{^} = 2 \cdot 0, 5 = 1$ og $J = \frac{1}{2} (1 - 2)^{2} = 0, 5$ .

Steg 2. Start ved tapet: $\partial J / \partial \overset{y}{^} = \overset{y}{^} - y = - 1$ .

Steg 3. Vekten nærmest tapet: $\partial \overset{y}{^} / \partial w_{2} = h = 0, 5$ , så $\partial J / \partial w_{2} = - 1 \cdot 0, 5 = - 0, 5$ .

Steg 4. Videre bakover: $\partial \overset{y}{^} / \partial h = w_{2} = 2$ , $\partial h / \partial z = 1$ siden $z > 0$ , og $\partial z / \partial w_{1} = x = 1$ . Produktet er $\partial J / \partial w_{1} = - 1 \cdot 2 \cdot 1 \cdot 1 = - 2$ .

Steg 5. Oppdater: $w_{2} = 2 - 0, 1 \cdot (- 0, 5) = 2, 05$ og $w_{1} = 0, 5 - 0, 1 \cdot (- 2) = 0, 7$ . Et nytt forward pass gir $h = 0, 7$ , $\overset{y}{^} = 1, 435$ og $J \approx 0, 16$ . Tapet falt fra $0, 5$ .

Øving 1 av 2Flervalg

Hva er hovedideen i backpropagation?

Øving 2 av 2Tallsvar

Et nett har $\overset{y}{^} = w_{2} \cdot ReLU (w_{1} x)$ og tapet $J = \frac{1}{2} (\overset{y}{^} - y)^{2}$ . Med $x = 2$ , $y = 1$ , $w_{1} = 0, 5$ og $w_{2} = - 1$ : hva er $\partial J / \partial w_{1}$ ?

Steg 6 av 7

Dype nett: forsvinnende gradienter og ikke-konveks tap

Konsept

Kjerneregelen ganger sammen én aktiveringsderivert per lag, og det har en bakside. Med sigmoid er hver faktor høyst $0, 25$ , så i et nett med $L$ sigmoid-lag ganger aktiveringene alene gradienten til de første lagene med en faktor på høyst $0, 2 5^{L}$ . Allerede ved ti lag er faktoren under en milliontedel. De tidlige lagene lærer da nesten ingenting, selv om de senere lagene trenes fint. Dette kalles forsvinnende gradient. Motsatt kan store vekter gi gradienter som eksploderer.

Det er en hovedgrunn til at ReLU er standard i skjulte lag: den deriverte er 1 for aktive nevroner, så aktiveringen krymper ikke gradienten. God initialisering av vektene, normalisering mellom lagene og snarveiskoblinger som hopper over lag hjelper i samme retning.

Den andre utfordringen er formen på tapet. For lineær og logistisk regresjon er tapet konvekst, med én dal der gradient descent finner bunnen, som i kapittel 3. Et nevralt nett med skjulte lag har et ikke-konvekst tap. Det kan ha mange lokale minimum og flate platåer, og bare det å bytte om to skjulte nevroner gir et nytt, like godt minimum. Hvor treningen ender, avhenger derfor av startvektene og læringsraten. I store nett er de fleste lokale minimum nesten like gode, men det forklarer hvorfor to treninger med ulike frø kan gi ulike nett.

Interaktiv figur

To praktiske følger er viktige. Vektene må starte med små tilfeldige verdier: starter alle vektene i et lag likt, får nevronene like gradienter og forblir kopier av hverandre. Og læringsraten må tunes som i kapittel 3, siden en for stor læringsrate gir et tap som oscillerer eller eksploderer.

Prøv: Følg første iterasjon trinn for trinn, slå av «Forklar hvert trinn» og spill av til den grunne dalen; flytt så w₀ til høyre for toppen og spill av igjen.

Trinn 1 av 3 · StigningIterasjon 1: vi står i w = −0,5. Stigningen der er L′(w) = 0,888: tapet synker mot venstre, så vi skal til venstre.

η0,200L(w₀)2,66w₀ = −0,50Forløpkonvergerer

Læringsrate η0,200Startpunkt w₀−0,5

Iterasjon 0 / 30Forklar hvert trinn

Vis utregning

L(w) = 0,1w⁴ − 0,15w³ − 0,65w² + 0,4w + 3 · w ← w − η · L′(w), η = 0,200

Iterasjonene i gradient descent.
t	wₜ	L(wₜ)	L′(wₜ)
0	−0,500	2,66	0,888
1	−0,677	2,50	0,950
2	−0,867	2,32	0,928
3	−1,053	2,16	0,803
30	−1,495	1,95	0,000

η = 0,200 konvergerer: etter 30 steg er w ≈ −1,50 og L ≈ 1,95. Det er et lokalt minimum; det globale ligger ved w ≈ 2,33. Startpunktet avgjør hvor GD havner.

Laster interaktiv figur …

Figur 11.6Ikke-konveks tap: startpunktet avgjør dalen. En grunn dal ved w ≈ −1,5 og en dypere ved w ≈ 2,3, med en topp ved w ≈ 0,3 mellom dem.

Interaktiv

Øving 1 av 2Flervalg

Hva kan skje med trening av et nevralt nettverk når læringsraten er altfor høy?

Øving 2 av 2Tallsvar

Den deriverte av sigmoid er høyst $0, 25$ . I et nett med $L$ sigmoid-lag inneholder gradienten til det første laget et produkt av $L$ slike deriverte. Hva er det minste antallet lag $L$ der dette produktet garantert er mindre enn $0, 001$ ?

Steg 7 av 7

Eksamensfokus

Slik spørres det

Nevrale nett testes med små regnestykker og presise forklaringer:

Regn ut outputen til et perceptron eller et lite nett for gitte vekter og input, ofte med ReLU eller Heaviside. Skriv ned mellomverdiene.
Forklar hvorfor Heaviside ikke kan brukes med gradient descent, og hva som skjer med den deriverte.
XOR: vis eller forklar hvorfor ett perceptron ikke klarer det, og hva et skjult lag gjør.
Tell parametrene i et nett med gitte lagstørrelser, eller les av formen til en vektmatrise.
Backprop: regn ut én gradient med kjerneregelen i et lite nett, eller forklar hva backprop gjør og ikke gjør.
Velg aktivering i outputlaget for en oppgave, og forklar hvorfor de skjulte lagene trenger ikke-lineære aktiveringer.

Vanlig felleBackprop er ikke optimeringen

Backpropagation regner ut gradientene. Selve vektendringen gjøres av gradient descent eller en variant av den. Et svar som sier at backprop finner det globale minimumet, er feil på to måter.

Vanlig felleGlem ikke biasen i parametertellingen

Hvert nevron har én bias i tillegg til vektene. Et lag fra 5 til 8 nevroner har $5 \cdot 8 + 8 = 48$ parametre, ikke 40.

Sjekk deg selvHvorfor er ReLU god nok for gradient descent når den ikke er deriverbar i 0?Vis svar

Fordi scoren nesten aldri er nøyaktig 0, og for alle andre verdier finnes den deriverte, 0 eller 1. I 0 velger implementasjonen bare en verdi. Heaviside har også derivert overalt utenom 0, men den er 0 overalt og gir ingen informasjon. ReLU gir 1 på positiv side.

Sjekk deg selvHvorfor initialiserer vi ikke alle vektene til 0?Vis svar

Da får alle nevronene i et lag samme output og samme gradient, og de forblir identiske etter hver oppdatering. Laget oppfører seg som ett nevron. Små tilfeldige startverdier bryter symmetrien.

Øving 1 av 3Flervalg

Hva gjør sigmoid i et binært outputlag?