Softmax-funktion - Softmax function

Den Softmax-funktion, også kendt som softargmax eller normaliseret eksponentiel funktion , er en generalisering af logistisk funktion til flere dimensioner. Det bruges i multinomial logistisk regression og bruges ofte som den sidste aktiveringsfunktion i et neuralt netværk for at normalisere output fra et netværk til en sandsynlighedsfordeling over forudsagte outputklasser, baseret på Luces valgaksiom .

Softmax-funktionen tager som input en vektor z af K- reelle tal og normaliserer den til en sandsynlighedsfordeling bestående af K- sandsynligheder, der er proportional med eksponentialerne for inputnumrene. Det vil sige, at visse vektorkomponenter inden anvendelse af softmax kan være negative eller større end en; og muligvis ikke summe til 1; men efter anvendelse af softmax vil hver komponent være i intervallet , og komponenterne tilføjes op til 1, så de kan fortolkes som sandsynligheder. Desuden svarer de større inputkomponenter til større sandsynligheder. ${\ displaystyle [0,1]}$

Standard (enhed) softmax-funktionen er defineret af formlen ${\ displaystyle \ sigma: \ mathbb {R} ^ {K} \ til [0,1] ^ {K}}$

${\ displaystyle \ sigma (\ mathbf {z}) _ {i} = {\ frac {e ^ {z_ {i}}} {\ sum _ {j = 1} ^ {K} e ^ {z_ {j} }}} \ \ \ \ {\ text {for}} i = 1, \ dotsc, K {\ text {and}} \ mathbf {z} = (z_ {1}, \ dotsc, z_ {K}) \ i \ mathbb {R} ^ {K}.}$

I enkle ord anvender den standardeksponentiel funktion på hvert element i inputvektoren og normaliserer disse værdier ved at dividere med summen af ​​alle disse eksponentielle; denne normalisering sikrer, at summen af ​​komponenterne i outputvektoren er 1. ${\ displaystyle z_ {i}}$${\ displaystyle \ mathbf {z}}$${\ displaystyle \ sigma (\ mathbf {z})}$

I stedet for e kan en anden base b > 0 bruges. Hvis 0 < b <1 , vil mindre inputkomponenter resultere i større output sandsynligheder, og faldende værdien af b vil skabe sandsynlighedsfordelinger, der er mere koncentreret omkring positionerne for de mindste inputværdier. Omvendt, hvis b > 1 , vil større inputkomponenter resultere i større output sandsynligheder, og at øge værdien af b vil skabe sandsynlighedsfordelinger, der er mere koncentreret omkring positionerne for de største inputværdier. Skrivning eller (for ægte β ) giver udtryk: ${\ displaystyle b = e ^ {\ beta}}$${\ displaystyle b = e ^ {- \ beta}}$

${\ displaystyle \ sigma (\ mathbf {z}) _ {i} = {\ frac {e ^ {\ beta z_ {i}}} {\ sum _ {j = 1} ^ {K} e ^ {\ beta z_ {j}}}} {\ text {eller}} \ sigma (\ mathbf {z}) _ {i} = {\ frac {e ^ {- \ beta z_ {i}}} {\ sum _ {j = 1} ^ {K} e ^ {- \ beta z_ {j}}}} {\ text {for}} i = 1, \ dotsc, K.}$

I nogle felter er basen fast svarende til en fast skala, mens i andre varieres parameteren β .

Fortolkninger

Glat arg max

Navnet "softmax" er vildledende; funktionen er ikke et glat maksimum (en jævn tilnærmelse til den maksimale funktion), men er snarere en jævn tilnærmelse til arg max- funktionen: den funktion, hvis værdi er, hvilket indeks har det maksimale. Faktisk bruges udtrykket "softmax" også om den nært beslægtede LogSumExp- funktion, som er et glat maksimum. Af denne grund foretrækker nogle det mere nøjagtige udtryk "softargmax", men udtrykket "softmax" er konventionelt i maskinindlæring. Dette afsnit bruger udtrykket "softargmax" for at understrege denne fortolkning.

Formelt, i stedet for at betragte arg max som en funktion med kategorisk output (svarende til indekset), skal du overveje arg max-funktionen med en hot- repræsentation af output (forudsat at der er en unik maksimal arg): ${\ displaystyle 1, \ prikker, n}$

${\ displaystyle \ operatorname {arg \, max} (z_ {1}, \ dots, z_ {n}) = (y_ {1}, \ dots, y_ {n}) = (0, \ dots, 0,1 , 0, \ prikker, 0),}$

hvor outputkoordinaten hvis og kun hvis er arg max for , betyder den unikke maksimale værdi af . For eksempel i denne kodning, da det tredje argument er det maksimale. ${\ displaystyle y_ {i} = 1}$${\ displaystyle i}$${\ displaystyle (z_ {1}, \ prikker, z_ {n})}$${\ displaystyle z_ {i}}$${\ displaystyle (z_ {1}, \ prikker, z_ {n})}$${\ displaystyle \ operatorname {arg \, max} (1,5,10) = (0,0,1),}$

Dette kan generaliseres til flere arg max-værdier (multiple lig med maksimum) ved at dividere 1 mellem alle max args; formelt 1 / k hvor k er antallet af argumenter, der antager det maksimale. For eksempel, da det andet og tredje argument begge er det maksimale. Hvis alle argumenter er ens, er dette simpelthen Points z med flere arg max-værdier er entalpoint (eller singulariteter og danner entalssættet) - det er de punkter, hvor arg max er diskontinuerligt (med spring-diskontinuitet ) - mens point med en enkelt arg max er kendt som ikke-ental eller regelmæssige punkter. ${\ displaystyle z_ {i}}$${\ displaystyle \ operatorname {arg \, max} (1,5,5) = (0,1 / 2,1 / 2),}$${\ displaystyle \ operatorname {arg \, max} (z, \ dots, z) = (1 / n, \ dots, 1 / n).}$

Med det sidste udtryk i introduktionen er softargmax nu en glat tilnærmelse af arg max: da softargmax konvergerer til arg max. Der er forskellige forestillinger om konvergens af en funktion; softargmax konvergerer til arg max punktvis , hvilket betyder for hver fast input z som , imidlertid softargmax ikke konvergerer ensartet at arg max, hvilket betyder intuitivt at forskellige punkter konvergerer ved forskellige hastigheder og kan konvergere vilkårligt langsomt. Faktisk er softargmax kontinuerligt, men arg max er ikke kontinuerligt i entalsættet, hvor to koordinater er ens, mens den ensartede grænse for kontinuerlige funktioner er kontinuerlig. Årsagen til, at det ikke konvergerer ensartet, er at for input, hvor to koordinater er næsten ens (og den ene er maksimum), er arg max indekset for den ene eller den anden, så en lille ændring i input giver en stor ændring i output. For eksempel, men og for alle indgange: Jo tættere punkterne er på entalsættet , jo langsommere konvergerer de. Softargmax konvergerer dog kompakt på det ikke- entalssæt . ${\ displaystyle \ beta \ to \ infty}$${\ displaystyle \ beta \ to \ infty}$${\ displaystyle \ sigma _ {\ beta} (\ mathbf {z}) \ til \ operatorname {arg \, max} (\ mathbf {z}).}$${\ displaystyle \ sigma _ {\ beta} (1,1.0001) \ til (0,1),}$${\ displaystyle \ sigma _ {\ beta} (1,0.9999) \ til (1,0),}$${\ displaystyle \ sigma _ {\ beta} (1,1) = 1/2}$${\ displaystyle (x, x)}$

Omvendt, da softargmax konvergerer til arg min på samme måde, hvor her entalsættet er punkter med to arg min- værdier. På det tropiske analysesprog er softmax en deformation eller "kvantisering" af arg max og arg min svarende til brug af log-semiring i stedet for max-plus semiring (henholdsvis min-plus semiring ) og gendannelse af arg max eller arg min ved at tage grænsen kaldes "tropisering" eller "dekvantisering". ${\ displaystyle \ beta \ to - \ infty}$

Det er også tilfældet, at udgangen for enhver fast β , hvis en indgang er meget større end de andre i forhold til temperaturen, er arg arg. For eksempel er en forskel på 10 stor i forhold til en temperatur på 1: ${\ displaystyle z_ {i}}$${\ displaystyle T = 1 / \ beta}$

${\ displaystyle \ sigma (0,10): = \ sigma _ {1} (0,10) = \ left (1 / (1 + e ^ {10}), e ^ {10} / (1 + e ^ {10}) \ right) \ approx (0.00005,0.99995)}$

Men hvis forskellen er lille i forhold til temperaturen, er værdien ikke tæt på arg max. For eksempel er en forskel på 10 lille i forhold til en temperatur på 100:

${\ displaystyle \ sigma _ {1/100} (0,10) = \ left (1 / (1 + e ^ {1/10}), e ^ {1/10} / (1 + e ^ {1 / 10}) \ højre) \ ca. (0.475,0.525).}$

Da temperaturen går til nul, så i sidste ende bliver alle forskelle store (i forhold til en krympende temperatur), hvilket giver en anden fortolkning af grænseadfærden. ${\ displaystyle \ beta \ to \ infty}$${\ displaystyle T = 1 / \ beta \ til 0}$

Sandsynlighedsteori

I sandsynlighedsteori kan output fra softargmax-funktionen bruges til at repræsentere en kategorisk fordeling - det vil sige en sandsynlighedsfordeling over K forskellige mulige resultater.

Statistisk mekanik

I statistisk mekanik er softargmax-funktionen kendt som Boltzmann-distributionen (eller Gibbs-fordelingen ): indeksindstillingen er mikrostaterne i systemet; input er energierne i denne tilstand; nævneren er kendt som delingsfunktionen , ofte betegnet med Z ; og faktoren β kaldes kulde (eller termodynamisk beta eller invers temperatur ). ${\ displaystyle {1, \ dots, k}}$${\ displaystyle z_ {i}}$

Ansøgninger

Softmax-funktionen bruges i forskellige multiklassificeringsmetoder , såsom multinomial logistisk regression (også kendt som softmax-regression) [1] , multiklasse lineær diskriminerende analyse , naive Bayes-klassifikatorer og kunstige neurale netværk . Specifikt er input til funktionen i multinomial logistisk regression og lineær diskriminantanalyse resultatet af K- distinkte lineære funktioner , og den forudsagte sandsynlighed for j'te klasse givet en prøvevektor x og en vægtningsvektor w er:

${\ displaystyle P (y = j \ mid \ mathbf {x}) = {\ frac {e ^ {\ mathbf {x} ^ {\ mathsf {T}} \ mathbf {w} _ {j}}} {\ sum _ {k = 1} ^ {K} e ^ {\ mathbf {x} ^ {\ mathsf {T}} \ mathbf {w} _ {k}}}}}$

Dette kan ses som sammensætningen af K lineære funktioner og softmax-funktionen (hvor betegner det indre produkt af og ). Operationen svarer til at anvende en lineær operator defineret af vektorer og transformerer således det originale, sandsynligvis højdimensionelle, input til vektorer i et K- dimensionelt rum . ${\ displaystyle \ mathbf {x} \ mapsto \ mathbf {x} ^ {\ mathsf {T}} \ mathbf {w} _ {1}, \ ldots, \ mathbf {x} \ mapsto \ mathbf {x} ^ { \ mathsf {T}} \ mathbf {w} _ {K}}$${\ displaystyle \ mathbf {x} ^ {\ mathsf {T}} \ mathbf {w}}$${\ displaystyle \ mathbf {x}}$${\ displaystyle \ mathbf {w}}$${\ displaystyle \ mathbf {w}}$${\ displaystyle \ mathbf {x}}$${\ displaystyle \ mathbb {R} ^ {K}}$

Neurale netværk

Softmax-funktionen bruges ofte i det sidste lag af en neuralt netværksbaseret klassifikator. Sådanne netværk trænes almindeligvis under et logtab (eller kryds-entropi ) regime, hvilket giver en ikke-lineær variant af multinomial logistisk regression.

Da funktionen kortlægger en vektor og et specifikt indeks til en reel værdi, skal derivatet tage indekset i betragtning: ${\ displaystyle i}$

${\ displaystyle {\ frac {\ partial} {\ partial q_ {k}}} \ sigma ({\ textbf {q}}, i) = \ sigma ({\ textbf {q}}, i) (\ delta _ {ik} - \ sigma ({\ textbf {q}}, k)).}$

Dette udtryk er symmetrisk i indekserne og kan således også udtrykkes som ${\ displaystyle i, k}$

${\ displaystyle {\ frac {\ partial} {\ partial q_ {k}}} \ sigma ({\ textbf {q}}, i) = \ sigma ({\ textbf {q}}, k) (\ delta _ {ik} - \ sigma ({\ textbf {q}}, i)).}$

Her bruges Kronecker-deltaet for enkelhed (jf. Afledningen af ​​en sigmoid-funktion , der udtrykkes via selve funktionen).

Hvis funktionen skaleres med parameteren , skal disse udtryk ganges med . ${\ displaystyle \ beta}$${\ displaystyle \ beta}$

Se Multinomial logit for en sandsynlighedsmodel, der bruger softmax-aktiveringsfunktionen.

Forstærkning læring

Inden for forstærkningslæring kan en softmax-funktion bruges til at konvertere værdier til handlingssandsynligheder. Den almindeligt anvendte funktion er:

${\ displaystyle P_ {t} (a) = {\ frac {\ exp (q_ {t} (a) / \ tau)} {\ sum _ {i = 1} ^ {n} \ exp (q_ {t} (i) / \ tau)}} {\ text {,}}}$

hvor handlingsværdien svarer til den forventede belønning ved at følge handling a og kaldes en temperaturparameter (som en hentydning til statistisk mekanik ). Ved høje temperaturer ( ) har alle handlinger næsten samme sandsynlighed, og jo lavere temperatur, jo mere forventede belønninger påvirker sandsynligheden. For en lav temperatur ( ) har sandsynligheden for, at handlingen med den højeste forventede belønning er 1. ${\ displaystyle q_ {t} (a)}$${\ displaystyle \ tau}$${\ displaystyle \ tau \ to \ infty}$${\ displaystyle \ tau \ til 0 ^ {+}}$

Ejendomme

Geometrisk kortlægger softmax-funktionen vektorrummet til grænsen for standard -simplex og skærer dimensionen med en (området er en -dimensional simplex i -dimensionelt rum) på grund af den lineære begrænsning, at al output sum til 1 betyder, at den ligger på et hyperplan . ${\ displaystyle \ mathbb {R} ^ {K}}$${\ displaystyle (K-1)}$${\ displaystyle (K-1)}$${\ displaystyle K}$

Langs den vigtigste diagonale softmax er bare den ensartede fordeling på output : lige score giver lige sandsynligheder. ${\ displaystyle (x, x, \ prikker, x),}$${\ displaystyle (1 / n, \ prikker, 1 / n)}$

Mere generelt Softmax er invariant under oversættelse ved den samme værdi i hver koordinat: tilsætning til indgangene udbytter , fordi den multiplicerer hver eksponent med samme faktor, (fordi ), så forholdene ikke ændrer: ${\ displaystyle \ mathbf {c} = (c, \ prikker, c)}$${\ displaystyle \ mathbf {z}}$${\ displaystyle \ sigma (\ mathbf {z} + \ mathbf {c}) = \ sigma (\ mathbf {z})}$${\ displaystyle e ^ {c}}$${\ displaystyle e ^ {z_ {i} + c} = e ^ {z_ {i}} \ cdot e ^ {c}}$

${\ displaystyle \ sigma (\ mathbf {z} + \ mathbf {c}) _ {j} = {\ frac {e ^ {z_ {j} + c}} {\ sum _ {k = 1} ^ {K } e ^ {z_ {k} + c}}} = {\ frac {e ^ {z_ {j}} \ cdot e ^ {c}} {\ sum _ {k = 1} ^ {K} e ^ { z_ {k}} \ cdot e ^ {c}}} = \ sigma (\ mathbf {z}) _ {j}.}$

Geometrisk er softmax konstant langs diagonaler: dette er den dimension, der elimineres og svarer til, at softmax-output er uafhængig af en oversættelse i inputscores (et valg på 0-score). Man kan normalisere input-scores ved at antage, at summen er nul (træk gennemsnittet: hvor ), og derefter tager softmax hyperplanet af punkter, der summer til nul,, til den åbne simplex af positive værdier, der summerer til 1 , analogt med hvordan eksponenten tager 0 til 1 og er positiv. ${\ displaystyle \ mathbf {c}}$${\ textstyle c = {\ frac {1} {n}} \ sum z_ {i}}$${\ textstyle \ sum z_ {i} = 0}$${\ textstyle \ sum \ sigma (\ mathbf {z}) _ {i} = 1}$${\ displaystyle e ^ {0} = 1}$

Derimod er softmax ikke uændret under skalering. For eksempel, men${\ displaystyle \ sigma {\ bigl (} (0,1) {\ bigr)} = {\ bigl (} 1 / (1 + e), e / (1 + e) ​​{\ bigr)}}$${\ displaystyle \ sigma {\ bigl (} (0,2) {\ bigr)} = {\ bigl (} 1 / (1 + e ^ {2}), e ^ {2} / (1 + e ^ { 2}) {\ bigr)}.}$

Den standard logistisk funktion er det specielle tilfælde for en 1-dimensional akse i 2-dimensionelle rum, sige x -aksen i (x, y) plan. En variabel er fast på 0 (siger ), så , og den anden variabel kan variere, betegne den , så standardlogistikfunktionen og dens komplement (hvilket betyder, at de tilføjer op til 1). Den 1-dimensionelle input kan alternativt udtrykkes som linjen med output og${\ displaystyle z_ {2} = 0}$${\ displaystyle e ^ {0} = 1}$${\ displaystyle z_ {1} = x}$${\ textstyle e ^ {z_ {1}} / \ sum _ {k = 1} ^ {2} e ^ {z_ {k}} = e ^ {x} / (e ^ {x} +1),}$${\ textstyle e ^ {z_ {2}} / \ sum _ {k = 1} ^ {2} e ^ {z_ {k}} = 1 / (e ^ {x} +1),}$${\ displaystyle (x / 2, -x / 2)}$${\ displaystyle e ^ {x / 2} / (e ^ {x / 2} + e ^ {- x / 2}) = e ^ {x} / (e ^ {x} +1)}$${\ displaystyle e ^ {- x / 2} / (e ^ {x / 2} + e ^ {- x / 2}) = 1 / (e ^ {x} +1).}$

Softmax-funktionen er også gradienten af LogSumExp- funktionen, et jævnt maksimum :

${\ displaystyle {\ frac {\ partial} {\ partial z_ {i}}} \ operatorname {LSE} (\ mathbf {z}) = {\ frac {\ exp z_ {i}} {\ sum _ {j = 1} ^ {K} \ exp z_ {j}}} = \ sigma (\ mathbf {z}) _ {i}, \ quad {\ text {for}} i = 1, \ dotsc, K, \ quad \ mathbf {z} = (z_ {1}, \ dotsc, z_ {K}) \ i \ mathbb {R} ^ {K},}$

hvor LogSumExp-funktionen er defineret som . ${\ displaystyle \ operatorname {LSE} (z_ {1}, \ dots, z_ {n}) = \ log \ left (\ exp (z_ {1}) + \ cdots + \ exp (z_ {n}) \ right )}$

Historie

Softmax-funktionen blev brugt i statistisk mekanik som Boltzmann-distributionen i det grundlæggende papir Boltzmann (1868) , formaliseret og populariseret i den indflydelsesrige lærebog Gibbs (1902) .

Brugen af ​​softmax i beslutningsteori krediteres Luce (1959) , der brugte uafhængighedsaksiomet for irrelevante alternativer i rationel valgteori for at udlede softmax i Luces valgaksiom for relative præferencer. harvtxt-fejl: intet mål: CITEREFLuce1959 ( hjælp )

I maskinindlæring krediteres udtrykket "softmax" til John S. Bridle i to konferenceaviser fra 1989, Bridle (1990a) : og Bridle (1990b) :

Vi er bekymrede over feed-forward ikke-lineære netværk (multi-lags perceptroner eller MLP'er) med flere output. Vi ønsker at behandle netværksudgange som sandsynligheder for alternativer ( f.eks. Mønsterklasser), betinget af indgangene. Vi ser efter passende output-ikke-lineariteter og efter passende kriterier for tilpasning af netværkets parametre ( f.eks. Vægte). Vi forklarer to ændringer: sandsynlighedsscoring, som er et alternativ til kvadratisk fejlminimering , og en normaliseret eksponentiel ( softmax ) multi-input generalisering af den logistiske ikke-linearitet.

For ethvert input skal outputene alle være positive, og de skal summe til enhed. ...

Med et sæt ubegrænsede værdier kan vi sikre begge betingelser ved hjælp af en normaliseret eksponentiel transformation: ${\ displaystyle V_ {j} (x)}$

${\ displaystyle Q_ {j} (x) = \ left.e ^ {V_ {j} (x)} \ right / \ sum _ {k} e ^ {V_ {k} (x)}}$

Denne transformation kan betragtes som en generalisering af logistikken med flere input, der fungerer på hele outputlaget. Det bevarer rangordenen for dets inputværdier og er en differentierbar generalisering af 'vinder-tag-alt'-operationen med at vælge den maksimale værdi. Af denne grund henviser vi gerne til det som softmax .

Eksempel

Hvis vi tager et input på [1, 2, 3, 4, 1, 2, 3], er softmax for det [0,024, 0,064, 0,175, 0,475, 0,024, 0,064, 0,175]. Outputtet har det meste af sin vægt, hvor '4' var i den originale input. Dette er, hvad funktionen normalt bruges til: at fremhæve de største værdier og undertrykke værdier, der er væsentligt under den maksimale værdi. Men bemærk: softmax er ikke uændret i skala, så hvis input var [0,1, 0,2, 0,3, 0,4, 0,1, 0,2, 0,3] (hvilket svarer til 1,6), ville softmax være [0,125, 0,138, 0,153, 0,169, 0,125, 0,138, 0,153]. Dette viser, at for værdier mellem 0 og 1 softmax faktisk understreger den maksimale værdi (bemærk, at 0,169 ikke kun er mindre end 0,475, det er også mindre end den indledende andel på 0,4 / 1,6 = 0,25).

Beregning af dette eksempel ved hjælp af Python- kode:

>>> import numpy as np
>>> a = [1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0]
>>> np.exp(a) / np.sum(np.exp(a)) 
array([0.02364054, 0.06426166, 0.1746813, 0.474833, 0.02364054,
       0.06426166, 0.1746813])

Her er et eksempel på Julia- kode:

julia> A = [1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0];  # semicolon to suppress interactive output

julia> exp.(A) ./ sum(exp.(A))
7-element Array{Float64,1}:
 0.0236405
 0.0642617
 0.174681
 0.474833
 0.0236405
 0.0642617
 0.174681

Her er et eksempel på R- kode:

> z <- c(1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0)
> softmax <- exp(z)/sum(exp(z))
> softmax
[1] 0.02364054 0.06426166 0.17468130 0.47483300 0.02364054 0.06426166 0.17468130

Her er et eksempel på Elixir- kode:

iex> t = Nx.tensor([[1, 2], [3, 4]])
iex> Nx.divide(Nx.exp(t), Nx.sum(Nx.exp(t)))

#Nx.Tensor<
  f64[2][2]
  [
    [0.03205860328008499, 0.08714431874203257],
    [0.23688281808991013, 0.6439142598879722]
  ]
>

Se også

• Softplus
• Multinomial logistisk regression
• Dirichlet distribution - en alternativ måde at prøve kategoriske distributioner på
• Opdelingsfunktion

Bemærkninger

Referencer