Lära Förlustfunktion | Neuronnätverk Från Grunden

Vid träning av ett neuralt nätverk behöver vi ett sätt att mäta hur väl vår modell presterar. Detta görs med hjälp av en förlustfunktion, som kvantifierar skillnaden mellan de förutsagda utgångarna och de faktiska målvärdena. Målet med träningen är att minimera denna förlust, så att våra förutsägelser blir så nära de faktiska värdena som möjligt.

En av de vanligaste förlustfunktionerna för binär klassificering är korsentropiförlusten, som fungerar väl med modeller som ger sannolikheter som utdata.

Härledning av korsentropiförlust

För att förstå korsentropiförlust utgår vi från maximum likelihood-principen. I ett problem med binär klassificering är målet att träna en modell som uppskattar sannolikheten $\hat{y}$ att en given indata tillhör klass 1. Den faktiska etiketten $y$ kan vara antingen 0 eller 1.

En bra modell bör maximera sannolikheten att korrekt förutsäga alla träningsexempel. Detta innebär att vi vill maximera likelihoodfunktionen, som representerar sannolikheten att observera data givet modellens förutsägelser.

För ett enskilt träningsexempel, under antagande om oberoende, kan likelihood skrivas som:

P(y|x) = \hat{y}^y(1 - \hat{y})^{1-y}

Detta uttryck betyder helt enkelt:

Om $y = 1$ , då är $P(y|x) = \hat{y}$ , vilket innebär att vi vill maximera $\hat{y}$ (sannolikheten tilldelad till klass 1);
Om $y = 0$ , då är $P(y|x) = 1 - \hat{y}$ , vilket innebär att vi vill maximera $1 - \hat{y}$ (sannolikheten tilldelad till klass 0).

Notera

$P(y|x)$ betyder sannolikheten att observera den faktiska klassetiketten $y$ givet indata $x$ .

För att förenkla optimeringen använder vi log-likelihood istället för själva likelihood (eftersom logaritmer omvandlar produkter till summor, vilket gör derivering enklare):

\log P(y|x) = y\log(\hat{y}) + (1-y)\log(1-\hat{y})

Eftersom målet är maximering definierar vi förlustfunktionen som den negativa log-likelihooden, vilket vi vill minimera:

L = -(y\log(\hat{y}) + (1-y)\log(1-\hat{y}))

Detta är binär korsentropiförlustfunktion, vanligt förekommande vid klassificeringsproblem.

Givet att variabeln output representerar $\hat{y}$ för ett specifikt träningsfall, och variabeln target representerar $y$ för detta träningsfall, kan denna förlustfunktion implementeras enligt följande:

import numpy as np

loss = -(target * np.log(output) + (1 - target) * np.log(1 - output))

Varför denna formel?

Korsentropiförlust har en tydlig intuitiv tolkning:

Om $y = 1$ förenklas förlusten till $-\log(\hat{y})$ , vilket innebär att förlusten är låg när $\hat{y}$ är nära 1 och mycket hög när $\hat{y}$ är nära 0;
Om $y = 0$ förenklas förlusten till $-\log(1 - \hat{y})$ , vilket innebär att förlusten är låg när $\hat{y}$ är nära 0 och mycket hög när den är nära 1.

Eftersom logaritmer växer negativt stora när deras indata närmar sig noll, straffas felaktiga förutsägelser kraftigt, vilket uppmuntrar modellen att göra säkra, korrekta förutsägelser.

Om flera exempel skickas under framåtriktad propagiering beräknas den totala förlusten som genomsnittlig förlust över alla exempel:

L = -\frac1N \sum_{i=1}^N (y_i\log(\hat{y}_i) + (1-y_i)\log(1-\hat{y}_i))

där $N$ är antalet träningsprover.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 6

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Awesome!

Completion rate improved to 4

Svep för att visa menyn