Online maskininlärning

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 9 november 2021; kontroller kräver 2 redigeringar .

Online maskininlärning är en maskininlärningsteknik där data görs tillgängliga i sekventiell ordning och används för att uppdatera den bästa förutsägelsen för efterföljande data, utförd vid varje träningssteg. Metoden är motsatt till batch-träningstekniken, där den bästa förutsägelsen genereras på en gång från hela träningsdataset. Onlineinlärning är en vanlig teknik som används inom områden av maskininlärning när det inte går att träna på hela datasetet, som när det finns behov av algoritmer som fungerar med externt minne. Metoden används även i situationer där algoritmen dynamiskt måste anpassa nya mönster i datan, eller när själva datan bildas som en funktion av tiden, till exempel vid förutsägelse av kurser på aktiemarknaden . Online-inlärningsalgoritmer kan vara benägna att drabbas av katastrofala störningar , ett problem som kan lösas med en steg-för- steg-inlärningsmetod [1] .

Inledning

Under övervakade inlärningsförhållanden tränas en funktion , där den betraktas som utrymmet för indata, och är utrymmet för utdata, som förutsäger väl på elementen i den gemensamma sannolikhetsfördelningen på . I verkligheten, i träning, är den verkliga fördelningen aldrig känd. Vanligtvis, tvärtom, finns det tillgång till utbildningsuppsättningen med exempel . Under dessa förhållanden ges förlustfunktionen som , så att den mäter skillnaden mellan det förutsagda värdet och det verkliga värdet av . Det ideala målet är att välja en funktion , där är ett rymd av funktioner, kallat hypotesutrymme, så att den totala förlusten är minimal i någon mening. Beroende på typ av modell (statistisk eller kontradiktorisk) kan olika förlustbegrepp utvecklas som leder till olika inlärningsalgoritmer. $f:X\to Y$ $X$ $Y$ $p(x,y)$ $X \ gånger Y$ $p(x,y)$ $(x_{1},y_{1}),\ldots ,(x_{n},y_{n})$ $V:Y\times Y\to \mathbb {R}$ $V(f(x),y)$ $f(x)$ $y$ $f\in {\mathcal {H}}$ ${\mathcal {H}}$

En statistisk syn på onlineinlärning

I statistiska inlärningsmodeller antas provet tas från den sanna fördelningen och målet med lärandet är att minimera den förväntade "risken" $(x_{i},y_{i})$ $p(x,y)$

I[f]=\mathbb {E} [V(f(x),y)]=\int V(f(x),y)\,dp(x,y)\ .

Det allmänna paradigmet i denna situation är att utvärdera funktionen genom att minimera empiriska risker eller minimera regulariserade empiriska risker (typiskt med hjälp av Tikhonovs regularisering ). Valet av förlustfunktion här ger flera välkända inlärningsalgoritmer som regulariserade minsta kvadrater och stödvektormaskiner . En rent onlinemodell i den här kategorin skulle vara att träna endast på nya ingångar , den nuvarande bästa prediktorn och lite extra lagrad information (som vanligtvis har minneskrav oberoende av storleken på datan). För många probleminställningar, såsom icke-linjära kärnmetoder , är sann onlineinlärning inte möjlig, även om hybridformer av onlineinlärning med rekursiva algoritmer kan användas, där värdet tillåts bero på och alla tidigare datapunkter . I det här fallet kan minneskraven inte längre begränsas eftersom alla tidigare punkter måste behållas, men lösningen kan ta kortare tid att beräkna med nya datapunkter som lagts till än batchinlärningstekniker. ${\hat {f))$ $(x_{t+1},y_{t+1})$ ${\displaystyle f_{t))$ $f_{t+1}$ $med$ $(x_{1},y_{1}),\ldots ,(x_{t},y_{t})$

En vanlig strategi för att hantera detta problem är mini-batch-inlärning, där små partier av datapunkter bearbetas vid en tidpunkt, och detta kan ses som pseudo-online-inlärning för ett mycket mindre totalt antal utbildningspoäng. Minibatch-tekniken används med iterering över träningsdata för att erhålla en optimerad version av externa minnesmaskininlärningsalgoritmer, såsom stokastisk gradientnedstigning . I kombination med backpropagation är detta för närvarande den de facto träningsmetoden för artificiella neurala nätverk . $b\geq 1$ $b$

Exempel: linjära minsta kvadrater

Linjära minsta kvadrater används här för att förklara olika onlineinlärningsidéer. Idéerna är tillräckligt generella för att kunna tillämpas på andra inställningar, såsom andra konvexa förlustfunktioner .

Batchinlärning

I en övervakad miljö med en kvadratisk förlustfunktion är målet att minimera den empiriska förlusten

I_{n}[w]=\summa _{j=1}^{n}V(\langle w,x_{j}\rangle ,y_{j})=\summa _{j=1} ^{n}(x_{j}^{T}w-y_{j})^{2}

, var

x_{j}\in \mathbb {R} ^{d},w\in \mathbb {R} ^{d},y_{j}\in \mathbb {R}

Låt vara en matris av data och vara en matris av målvärden efter ankomsten av de första datapunkterna. Om man antar att kovariansmatrisen är inverterbar (annars bör en procedur som liknar Tikhonovs regularisering utföras), den bästa lösningen av minsta kvadratmetoden ges av jämlikheten $X$ $i\times d$ $Y$ $i\times 1$ $i$ $\Sigma _{i}=X^{T}X$ $f^{*}(x)=\langle w^{*},x\rangle$

w^{*}=(X^{T}X)^{-1}X^{T}Y=\Sigma _{i}^{-1}\sum _{j=1}^{ i}x_{j}y_{j}

Nu kommer beräkningen av kovariansmatrisen att ta tid, matrisinversionen tar tid och matrismultiplikationen tar tid, vilket ger den totala tiden . Om det finns totalt antal punkter i datamängden och du behöver räkna om lösningen efter att varje datapunkt anländer kommer det naturliga tillvägagångssättet att ha full komplexitet . Observera att om matrisen är lagrad, kräver uppdatering i varje steg endast tillägg , vilket tar tid, vilket minskar den totala tiden till , men kräver ytterligare lagringsutrymme [ 2] . ${\displaystyle \Sigma _{i}=\sum _{j=1}^{i}x_{j}x_{j}^{T))$ $O(id^{2})$ $d\times d$ $O(d^{3})$ $O(d^{2})$ $O(id^{2}+d^{3})$ $n$ $i=1,\ldots ,n$ $O(n^{2}d^{2}+nd^{3})$ ${\displaystyle \Sigma _{i))$ ${\displaystyle x_{i+1}x_{i+1}^{T))$ $O(d^{2})$ $O(nd^{2}+nd^{3})=O(nd^{3})$ $O(d^{2})$ ${\displaystyle \Sigma _{i))$

Onlineinlärning: rekursiva minsta kvadrater

Rekursiva minsta kvadrater överväger en online-strategi för minsta kvadrater. Det kan visas att med initiering och lösningen av den linjära minsta kvadratmetoden kan beräknas enligt följande: ${\displaystyle \textstyle w_{0}=0\in \mathbb {R} ^{d))$ ${\displaystyle \textstyle \Gamma _{0}=I\in \mathbb {R} ^{d\times d))$

\Gamma _{i}=\Gamma _{i-1}-{\frac {\Gamma _{i-1}x_{i}x_{i}^{T}\Gamma _{i-1 }}{1+x_{i}^{T}\Gamma _{i-1}x_{i}}}

w_{i}=w_{i-1}-\Gamma _{i}x_{i}(x_{i}^{T}w_{i-1}-y_{i})

Ovanstående iterativa algoritm kan bevisas genom induktion på [3] . Beviset visar också att . Man kan överväga rekursiva minsta kvadrater i samband med adaptiva filter (se Rekursiva minsta kvadrater ). $i$ ${\displaystyle \Gamma _{i}=\Sigma _{i}^{-1))$

Komplexiteten i stegen i denna algoritm är , vilket är snabbare än motsvarande batchinlärningskomplexitet. Minnet som krävs för varje steg för att lagra matrisen är här en konstant . För det fall då den inte är reversibel övervägs en regulariserad version av förlustfunktionen . Då är det lätt att visa att samma algoritm fungerar med , och fortsatta iterationer ger [2] . $n$ $O(nd^{2})$ $i$ $\Gamma _{i}$ $O(d^{2})$ ${\displaystyle \Sigma _{i))$ $\sum _{j=1}^{n}(x_{j}^{T}w-y_{j})^{2}+\lambda ||w||_{2}^{2 }$ ${\displaystyle \Gamma _{0}=(I+\lambda I)^{-1))$ ${\displaystyle \Gamma _{i}=(\Sigma _{i}+\lambda I)^{-1))$

Stokastisk gradientnedstigningsmetod

Om jämlikhet

\textstyle w_{i}=w_{i-1}-\Gamma _{i}x_{i}(x_{i}^{T}w_{i-1}-y_{i})

Ersatt av

\textstyle w_{i}=w_{i-1}-\gamma _{i}x_{i}(x_{i}^{T}w_{i-1}-y_{i})=w_ {i-1}-\gamma _{i}\nabla V(\langle w_{i-1},x_{i}\rangle ,y_{i})

eller på , detta blir en stokastisk gradientnedstigningsalgoritm. I det här fallet reduceras komplexiteten för stegen i denna algoritm till . Minnesbehovet vid varje steg är konstant . ${\displaystyle \Gamma _{i}\in \mathbb {R} ^{d\times d))$ $\gamma _{i}\in \mathbb {R}$ $n$ $O(nd)$ $i$ $O(d)$

Stegstorleken för att lösa det förväntade riskminimeringsproblemet bör dock väljas noggrant, som förklarats ovan. Genom att välja storleken på dämpningssteget kan konvergensen av den genomsnittliga iterationen bevisas . Dessa inställningar är ett specialfall av stokastisk optimering , ett välkänt optimeringsproblem [2] . ${\displaystyle \gamma _{i))$ ${\displaystyle \gamma _{i}\approx {\frac {1}{\sqrt {i))))$ ${\overline {w}}_{n}={\frac {1}{n}}\sum _{i=1}^{n}w_{i}$

Inkrementell Stokastisk Gradient Descent

I praktiken är det möjligt att utföra flera stokastiska gradientpassningar över data. Den resulterande algoritmen kallas den inkrementella gradientmetoden och motsvarar iterationen

\textstyle w_{i}=w_{i-1}-\gamma _{i}\nabla V(\langle w_{i-1},x_{t_{i}}\rangle ,y_{t_{ i)))

Den största skillnaden mot den stokastiska gradientmetoden är att man här väljer att bestämma vilken träningspunkt som besöks i steg . En sådan sekvens kan vara slumpmässig eller deterministisk. Antalet iterationer är alltså frikopplat från antalet punkter (varje punkt kan ses mer än en gång). Det kan visas att metoden med inkrementell gradient ger empirisk riskminimering [4] . Inkrementella tekniker kan ha fördelar när man betraktar den objektiva funktionen som summan av många element, till exempel som ett empiriskt fel i en mycket stor datamängd [2] . $t_{i}$ $i$

Nukleära metoder

Kärnor kan användas för att utöka ovanstående algoritmer till icke-parametriska modeller (eller modeller där parametrarna bildar ett oändligt dimensionellt utrymme). Motsvarande procedur kommer inte längre att vara riktigt online och i stället lagra alla datapunkter, men metoden förblir snabbare än brute force. Denna diskussion är begränsad till fallet med kvadratförlust, även om den kan utvidgas till vilken konvex förlustfunktion som helst. Det kan visas genom direkt induktion [2] att när a är en datamatris, är a utgången efter stegen i algoritmen för slumpmässig gradientnedstigning, då ${\displaystyle X_{i))$ $w_{i}$ $i$

{\displaystyle w_{i}=X_{i}^{T}c_{i))

var och sekvensen uppfyller de återkommande relationerna $\textstyle c_{i}=((c_{i})_{1},(c_{i})_{2},...,(c_{i})_{i})\in \mathbb {R} ^{i}$ ${\displaystyle c_{i))$

c_{0}=0

(c_{i})_{j}=(c_{i-1})_{j},j=1,2,...,i-1

och

{\displaystyle (c_{i})_{i}=\gamma _{i}{\Big (}y_{i}-\summa _{j=1}^{i-1}(c_{i-1 })_{j}\langle x_{j},x_{i}\rangle {\Big )))

Observera att här är standardkärnan i , och den prediktiva funktionen har formen $\langle x_{j},x_{i}\rangle$ ${\displaystyle \mathbb {R} ^{d))$

f_{i}(x)=\langle w_{i-1},x\rangle =\sum _{j=1}^{i-1}(c_{i-1})_{j} \langle x_{j},x\rangle

Om vi nu introducerar en gemensam kärna och representerar prediktionsfunktionen som $K$

f_{i}(x)=\sum _{j=1}^{i-1}(c_{i-1})_{j}K(x_{j},x)

då visar samma bevis att minsta kvadraters minimering av förlustfunktionen erhålls genom att ersätta ovanstående rekursion med

{\displaystyle (c_{i})_{i}=\gamma _{i}{\Big (}y_{i}-\summa _{j=1}^{i-1}(c_{i-1 })_{j}K(x_{j},x_{i}){\Big )))

Ovanstående uttryck kräver att man kommer ihåg all data för att uppdatera . Den totala tidskomplexiteten för rekursion, om den beräknas för den -:e datapunkten, är , där är kostnaden för att beräkna kärnan på ett par punkter [2] . Användning av kärnan tillåter sedan förflyttning från ett ändligt dimensionellt parameterutrymme till ett möjligen oändligt dimensionellt utrymme som representeras av kärnan , istället för att återkomma över parameterutrymmet , vars dimension är densamma som storleken på träningsdatauppsättningen. I allmänhet är detta tillvägagångssätt en konsekvens av representationssatsen [2] . ${\displaystyle c_{i))$ $n$ $O(n^{2}dk)$ $k$ ${\displaystyle \textstyle w_{i}\in \mathbb {R} ^{d))$ $K$ $\textstyle c_{i}\in \mathbb {R} ^{i}$

Progressivt lärande

Progressivt lärande är en effektiv inlärningsmodell som demonstreras av människors inlärningsprocess. Denna inlärningsprocess är kontinuerlig och kommer från direkt erfarenhet. Den progressiva inlärningstekniken inom maskininlärning kan lära sig nya klasser eller etiketter dynamiskt i farten [5] . Även om onlineutbildning kan träna nya dataprover som kommer in sekventiellt, kan de inte träna nya dataklasser . Det progressiva inlärningsparadigmet är oberoende av antalet klassbegränsningar och kan undervisa nya klasser samtidigt som kunskapen från tidigare klasser behålls. Men om en ny klass (inte naturligt förekommande) påträffas, byggs klassificeraren om automatiskt och parametrarna beräknas på ett sådant sätt att tidigare kunskaper behålls. Den här tekniken är lämplig för tillämpningar i verkliga världen där antalet klasser ofta är okänt och onlineinlärning från realtidsdata krävs.

Online konvex optimering

Online konvex optimering [6] är ett allmänt beslutsschema som använder konvex optimering för att erhålla effektiva algoritmer. Schemat är en multipel upprepning av följande åtgärder:

För $t=1,2,...,T$

Eleven får input ${\displaystyle x_{t))$
Eleven bildar en utgång från en fast konvex uppsättning ${\displaystyle w_{t))$ $S$
Naturen returnerar värdet av en konvex förlustfunktion . $v_{t}:S\rightarrow \mathbb {R}$
Eleven står för förlusten och uppdaterar modellen $v_{t}(w_{t})$

Målet är att minimera "ångrar" eller skillnaden mellan den totala förlusten och förlusten vid bästa fixpunkt i efterhand. Som ett exempel, betrakta fallet med linjär minsta kvadraters regression online. Här kommer vikten av vektorerna från en konvex mängd och naturen returnerar en konvex förlustfunktion . Observera att implicit skickas med . $u\in S$ ${\displaystyle S=\mathbb {R} ^{d))$ ${\displaystyle v_{t}(w)=(\langle w,x_{t}\rangle -y_{t})^{2))$ ${\displaystyle y_{t))$ ${\displaystyle v_{t))$

Vissa onlineförutsägelseproblem kan dock inte passa in i det konvexa optimeringsschemat online. Till exempel, i onlineklassificering är prediktionsområdet och förlustfunktionerna inte konvexa. I sådana scenarier används två enkla tekniker för reduktion av konvexa fall - randomisering och surrogatförlustfunktioner.

Några enkla konvexa optimeringsalgoritmer online:

Följ ledaren

Den enklaste inlärningsregeln för ett försök är att välja (vid det aktuella steget) den hypotes som har den minsta förlusten bland alla tidigare omgångar. Denna algoritm kallas " Följ ledaren " och ger helt enkelt en runda : $t$

w_{t}=\operatörsnamn {arg\,min} _{w\in S}\sum _{i=1}^{t-1}v_{i}(w)

Denna metod kan då ses som en girig algoritm . För fallet med online kvadratisk optimering (där förlustfunktionen är ), kan det visas att "ångra"-gränsen växer som . Liknande gränser kan dock inte erhållas för följ-ledaren-algoritmen för andra viktiga modellfamiljer som för linjär optimering online. För att få dem läggs regularisering till i algoritmen. $v_{t}(w)=||w-x_{t}||_{2}^{2}$ $\log(T)$

Följer en reguljär ledare

Detta är en naturlig modifiering av algoritmen för att följa ledaren som används för att stabilisera de ledare som följer besluten och få bättre ångergränser. En regulariseringsfunktion väljs och träningen genomförs i omgång t enligt följande: $R:S\rightarrow \mathbb {R}$

w_{t}=\operatörsnamn {arg\,min} _{w\in S}\sum _{i=1}^{t-1}v_{i}(w)+R(w)

Som ett specialfall, överväg fallet med linjär optimering online, det vill säga när naturen returnerar förlustfunktioner i formen . Låt också . Antag att regulariseringsfunktionen väljs för något positivt tal . Då kan det visas att iterationen att minimera "ångrar" övergår i $v_{t}(w)=\langle w,z_{t}\rangle$ ${\displaystyle S=\mathbb {R} ^{d))$ $R(w)={\frac {1}{2\eta }}||w||_{2}^{2}$ $\eta$

{\displaystyle w_{t+1}=-\eta \sum _{i=1}^{t}z_{i}=w_{t}-\eta z_{t))

Observera att detta kan skrivas om som , vilket ser exakt ut som metoden för gradientnedstigning online. $w_{t+1}=w_{t}-\eta \nabla v_{t}(w_{t})$

Om S är ett konvext delrum måste S projiceras, vilket resulterar i en modifierad uppdateringsregel ${\displaystyle \mathbb {R} ^{d))$

w_{t+1}=\Pi _{S}(-\eta \sum _{i=1}^{t}z_{i})=\Pi _{S}(\eta \theta _ {t+1})

Algoritmen är känd som lat projektion eftersom vektorn ackumulerar gradienter. Detta är också känt som Nesterovs dubbelmedelvärdesalgoritm (eller subgradient dubbelmedelvärdesmetoden [7] ). I det här scenariot är linjära förlustfunktioner och kvadratisk regularisering "regret" begränsad till , och då tenderar den genomsnittliga "regret" till 0 . $\theta _{t+1}$ $O({\sqrt {T)))$

Online subgradient descent

"Ånger" bunden för linjära förlustfunktioner har bevisats ovan . För att generalisera algoritmen till valfri konvex förlustfunktion används funktionen subgradient som en linjär approximation runt , vilket leder till online-subgradient descent-algoritmen: $v_{t}(w)=\langle w,z_{t}\rangle$ $\partial v_{t}(w_{t})$ ${\displaystyle v_{t))$ ${\displaystyle v_{t))$ ${\displaystyle w_{t))$

Initierar en parameter $\eta ,w_{1}=0$

För $t=1,2,...,T$

Vi gör en förutsägelse med hjälp av , vi får från naturen . ${\displaystyle w_{t))$ $med$
Välja $z_{t}\in \partial v_{t}(w_{t})$
Om , gör en uppdatering ${\displaystyle S=\mathbb {R} ^{d))$ ${\displaystyle w_{t+1}=w_{t}-\eta z_{t))$
Om , projektera kumulativa gradienter till dvs ${\displaystyle S\subset \mathbb {R} ^{d))$ $S$ ${\displaystyle w_{t+1}=\Pi _{S}(\eta \theta _{t+1}),\theta _{t+1}=\theta _{t}+z_{t))$

Du kan använda online-subgradient descent-algoritmen för att få "ångra"-gränserna för onlineversionen av stödvektormaskinen för klassificering, som använder en bitvis linjär förlustfunktion $O({\sqrt {T)))$ $v_{t}(w)=\max\{0,1-y_{t}(w\cdot x_{t})\}$

Andra algoritmer

Kvadratregulerade ledarföljande algoritmer leder till lat projicerade gradientalgoritmer, som beskrivits ovan. För att använda ovanstående tillvägagångssätt för alla konvexa funktioner och regularizers, kan online spegelnedstigning användas. Optimal regularisering i en bitvis linjär funktion kan erhållas för linjära förlustfunktioner, vilket leder till AdaGrad- algoritmen . För euklidisk regularisering kan det visas att "beklagandet" är lika och kan förbättras till strikt konvexa och exp-konkava förlustfunktioner. $O({\sqrt {T)))$ $O(\log T)$

Tolkning av onlinelärande

Onlineinlärningsparadigmet har olika tolkningar beroende på valet av inlärningsmodell, var och en med olika kvalitet på förutsägelser om funktionssekvenser . För diskussion använder vi den stokastiska gradientnedstigningsalgoritmen. Som noterats ovan ges rekursionen av algoritmen av likheten ${\displaystyle f_{1},f_{2},\ldots ,f_{n))$

\textstyle w_{t}=w_{t-1}-\gamma _{t}\nabla V(\langle w_{t-1},x_{t}\rangle ,y_{t})

Den första tolkningen betraktar den stokastiska gradientnedstigningsmetoden som en tillämpning på det förväntade riskminimeringsproblemet definierat ovan [8] . Dessutom, i fallet med en oändlig dataström, eftersom instanserna antas vara samplade från en oberoende och jämnt fördelad fördelning , är gradientsekvenserna i iterationen ovan oberoende och jämnt fördelade urval av den förväntade riskstokastiska gradientuppskattningen , och därför man kan tillämpa komplexitetsresultaten för den stokastiska gradientnedstigningsmetoden för att begränsa avvikelsen , där är minimeraren [9] . Denna tolkning gäller även för ändliga träningsuppsättningar. Även om gradienterna inte längre kommer att vara oberoende när man itererar över data, kan komplexitetsresultat i speciella fall erhållas. $I[w]$ $(x_{1},y_{1}),(x_{2},y_{2}),\ldots$ $p(x,y)$ $V(\cdot ,\cdot )$ $I[w]$ $I[w_{t}]-I[w^{\ast }]$ $w^{\ast }$ $I[w]$

Den andra tolkningen tillämpas på fallet med en finit träningsuppsättning och betraktar den stokastiska gradientnedstigningsalgoritmen som en representant för inkrementell gradientnedstigning [4] . I det här fallet kan man titta på den empiriska risken:

I_{n}[w]={\frac {1}{n}}\sum _{i=1}^{n}V(\langle w,x_{i}\rangle ,y_{i} )\ .

Eftersom gradienterna i iterationer av inkrementell gradientnedstigning är stokastiska uppskattningar av gradienten , är denna tolkning relaterad till metoden för stokastisk gradientnedstigning, men tillämpas på empirisk riskminimering i motsats till förväntad risk. Eftersom denna tolkning handlar om empirisk risk snarare än förväntad risk, är flera övergångar över data helt giltiga och leder faktiskt till snäva variansgränser , där . $V(\cdot ,\cdot )$ $I_{n}[w]$ $I_{n}[w_{t}]-I_{n}[w_{n}^{\ast }]$ ${\displaystyle w_{n}^{\ast ))$ $I_{n}[w]$

Implementeringar

Vowpal Wabbit : Ett snabbt onlineinlärningssystem med öppen källkod, externt minne med en uppsättning maskininlärningstekniker som stöds, med viktning av vikt och ett urval av olika förlustfunktioner och optimeringsalgoritmer. Systemet använder ett hashtrick för att begränsa storleken på funktionsuppsättningen oavsett storleken på träningsdata.
scikit-learn : Tillhandahåller en implementering av algoritmer som är slut på minnet för
- klassificerare: perceptron , statistisk gradient descent klassificerare , naiv bayes klassificerare .
- regressioner: stokastisk gradient descent regression, passiv aggressiv regressor.
- klustring: k-means metod .
- funktionsextraktion: mini-batch-ordförrådsinlärning , inkrementell huvudkomponentanalys .

Se även

Hierarkiskt temporärt minne
k-närmaste granne metod
Lat learning
Vektorkvantisering under träning
Offlineinlärning , motsatt modell
Onlinealgoritm
Strömningsalgoritm
perceptron
Stokastisk gradientnedstigning
Att lära sig med en lärare
Onlineoptimering

Anteckningar

↑ Katastrofal störning är tendensen hos artificiella neurala nätverk att plötsligt helt glömma allt som nätverket har tränats för att göra tidigare.
↑ 1 2 3 4 5 6 7 Rosasco, Poggio, 2015 .
↑ Yin, Kushner, 2003 , sid. 8–12.
↑ 12 Bertsekas , 2011 .
↑ Venkatesan, Meng Joo, 2016 , sid. 310–321.
↑ Hazan, 2015 .
↑ Dolgopolik, 2016 .
↑ Bottou, 1998 .
↑ Kushner, Yin, 1997 .

Litteratur

Leon Bottou. Onlinealgoritmer och Stokastiska Approximationer // Onlineinlärning och neurala nätverk . - Cambridge University Press, 1998. - ISBN 978-0-521-65263-6 .
Rosasco L., Poggio T. Kapitel 7 - Onlineinlärning // Machine Learning: a Regularization Approach . MIT-9.520 föreläsningsanteckningar. - 2015. - (Manuskript).
Harold J. Kushner, G. George Yin. Stokastiska approximationsalgoritmer och tillämpningar. - New York: Springer-Verlag, 1997. - ISBN 0-387-94916-X .
- Harold J. Kushner, G. George Yin. Stokastisk approximation och rekursiva algoritmer och tillämpningar. - 2:a upplagan - New York: Springer-Verlag, 2003. - ISBN 0-387-00894-2 .
Elad Hazan. Introduktion till konvex optimering online . — Foundations and Trends® in Optimization, 2015.
Rajasekar Venkatesan, Er Meng Joo. En ny progressiv inlärningsteknik för klassificering i flera klasser // Neurocomputing. - 2016. - T. 207 . - doi : 10.1016/j.neucom.2016.05.006 . - arXiv : 1609.00085 .
Dolgopolik MV Nesterovs metod för att minimera konvexa funktioner. — 2016.
Harold J. Yin, G. George Kushner. Stokastisk approximation och rekursiva algoritmer och applikationer. — För det andra. - New York: Springer, 2003. - ISBN 978-0-387-21769-7 .
Bertsekas DP Inkrementella gradient-, subgradient- och proximala metoder för konvex optimering: en undersökning // Optimization for Machine Learning. - 2011. - Utgåva. 85 .

Länkar

http://onlineprediction.net/ Arkiverad 31 oktober 2018 på Wayback Machine , Wiki for On-Line Prediction.

Maskininlärning och datautvinning
Uppgifter	Klassificeringsproblem Lärande utan lärare Lärarassisterat lärande Regressionsanalys AutoML Föreningens regler Särdragsextraktion Egenskapsträning Ranking utbildning Grammatisk härledning Online lärande
Att lära sig med en lärare	k-närmaste granne metod Naiv Bayes klassificerare beslutsträd Stöd vektor maskin Linjär regression Logistisk tillbakagång perceptron Ensembler av modeller Säckväv förstärkning slumpmässig skog Relevant vektormetod
klusteranalys	k-betyder metod Fuzzy klustringsmetod Hierarkisk klustring EM algoritm BJÖRK BOTA DBSCAN OPTIK Genomsnittlig förskjutning
Dimensionalitetsreduktion	Faktoranalys Huvudkomponentmetoden CCA ICA LDA Icke-negativ matrisexpansion t-SNE
Strukturell prognos	Graph probabilistisk modell Bayesiskt nätverk Dold Markov-modell CRF
Anomali upptäckt	k-närmaste granne metod Lokal utsläppsnivå
Grafisk probabilistiska modeller	Bayesiskt nätverk Markov nätverk Dold Markov-modell
Neurala nätverk	Begränsad Boltzmann-maskin självorganiserande karta Aktiveringsfunktion Sigmoid softmax Radiell basfunktion Ryggförökningsmetod Djup lärning Flerskiktsperceptron Återkommande neurala nätverk långtidsminne Kontrollerat återkommande block Konvolutionellt neuralt nätverk U-nät Autokodare
Förstärkningsinlärning	Markov process Bellmans ekvation Girig algoritm Q-lärande SARSA Temporell skillnad (TD)
Teori	Vapnik-Chervonenkis teori Bias-Dispersion Dilemma Beräkningslärandeteori Empirisk riskminimering Occam lär sig PAC-inlärning Statistisk inlärningsteori
Tidskrifter och konferenser	NeurIPS ICML ML JMLR ArXiv:cs.LG