Begreper & referanser
Alle nøkkelbegrepene, formlene og referansene fra Nevrale nettverk: fra perceptron til backpropagation, samlet på én side. Bruk denne som oppslag når du leser, øver flashcards eller tar quiz.
Begreper
Sentrale begreper fra kapittelet med korte definisjoner.
En enkel lineær klassifikator som kombinerer vektede input og en aktiveringsregel.
En beregningsenhet som summerer vektede input, legger til bias og bruker en aktiveringsfunksjon.
En funksjon som omformer nevronets score og gir nettverket ikke-lineær uttrykksevne.
Et lag mellom input og output som lærer mellomrepresentasjoner av dataene.
Beregningen som fører input gjennom nettverket fram til prediksjon og tap.
Effektiv beregning av gradienter ved å bruke kjerneregelen baklengs gjennom beregningsgrafen.
Trappefunksjonen for og ellers, brukt som aktivering i det klassiske perceptronet. Den deriverte er 0 overalt unntatt i , der den ikke finnes, så funksjonen gir ingen gradient å lære av.
To klasser er lineært separable hvis en rett linje, eller et hyperplan i flere dimensjoner, kan skille dem fullstendig. Et enkelt perceptron kan bare lære lineært separable problemer, og XOR er ikke et av dem.
Når gradienten blir svært liten i de første lagene fordi kjerneregelen ganger sammen mange små deriverte, for eksempel sigmoid-deriverte på høyst per lag. De tidlige lagene lærer da nesten ingenting.
Formler
Hver formel: hva den heter, hvordan den ser ut, og hva symbolene betyr.
Nevronets score
Et nevron summerer vektede innganger og et biasledd før aktiveringen brukes.
ReLU
ReLU setter negative scorer til null og lar positive scorer passere uendret.
Sigmoidaktivering
Sigmoid brukes blant annet i utgangen ved binær klassifikasjon.
Softmax
Softmax gjør scorer om til en sannsynlighetsfordeling som summerer til 1.
Forward pass i et lag
Et lag gjør en affin transformasjon av forrige aktivering og bruker deretter aktiveringsfunksjonen .
Kjerneregel
Backpropagation bruker kjerneregelen for å føre tapets gradient bakover gjennom beregningsgrafen.
Vektoppdatering
Hvert lag oppdateres mot lavere tap med gradienten som backpropagation har beregnet.
Heaviside-funksjon
Aktiveringen i det klassiske perceptronet. Den deriverte er 0 for alle og finnes ikke i , så gradient descent får ingen retning å gå i.
Sigmoid-derivert
Den deriverte av sigmoid uttrykt med sigmoid selv. Den er størst i , der den er , og går mot 0 når blir stor.
Perceptronregelen
Oppdateringen etter hvert treningspunkt. Er svaret riktig, er og ingenting endres. Er det feil, dyttes vektene i retning av eller bort fra .
Parametre i et lag
Et fullt koblet lag med input og nevroner har én vekt per par og én bias per nevron. Summen over alle lag er antall trenbare parametre.
Kodesnutter
Kodesnutter fra kapittelet, vist literal.
Forward pass i et lite nettverk
import numpy as np x1 = 2.0 # @param -2..2 0.5x2 = -1.0 # @param -2..2 0.5x = np.array([x1, x2]) # inputW1 = 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 outputb2 = -1.0 z1 = W1 @ x + b1 # skjult scoreh = np.maximum(0, z1) # ReLUz2 = w2 @ h + b2 # output-scorep = 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}")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.
Forward og ett backprop-steg i NumPy
import numpy as np sig = lambda z: 1 / (1 + np.exp(-z))x = np.array([1.0, 0.5]) # ett treningseksempel med fasit yy = 1 # @param 0..1W1 = np.array([[0.4, -0.6], [0.3, 0.8]]); b1 = np.zeros(2)w2 = np.array([0.7, -0.5]); b2 = 0.0eta = 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, dz2dz1 = dz2 * w2 * h * (1 - h) # dL/dh · dh/dz1dW1, db1 = np.outer(dz1, x), dz1 e = 1e-6; W1e = W1.copy(); W1e[0, 0] += e # numerisk kontroll av én vektprint(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}")Prøv: Bytt fasit med y og se «dL/dz2» og gradientene skifte fortegn, mens «tap før» → «etter» fortsatt synker.
Læringsmål
Hva du skal kunne etter å ha lest kapittelet.
- 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