Inlärning av flera kärnor

Multipel kärninlärning hänvisar till en uppsättning maskininlärningsmetoder som använder en fördefinierad uppsättning kärnor och lär sig en optimal linjär eller icke-linjär kombination av kärnor som en del av algoritmen. Anledningar till att använda multipelkärninlärning inkluderar a) möjligheten att välja för en optimal kärna och parametrar från en större uppsättning kärnor, minska bias på grund av kärnval samtidigt som det möjliggör mer automatiserade maskininlärningsmetoder, och b) kombinera data från olika källor ( t.ex. ljud och bilder från en video) som har olika föreställningar om likhet och därför kräver olika kärnor. Istället för att skapa en ny kärna kan flera kärnalgoritmer användas för att kombinera kärnor som redan är etablerade för varje enskild datakälla.

Flera kärnlärande tillvägagångssätt har använts i många applikationer, såsom händelseidentifiering i video, objektigenkänning i bilder och biomedicinsk datafusion.

Algoritmer

Flera kärninlärningsalgoritmer har utvecklats för övervakad, semiövervakad och oövervakad inlärning. Det mesta arbetet har gjorts på det övervakade inlärningsfallet med linjära kombinationer av kärnor, men många algoritmer har utvecklats. Grundidén bakom multipla kärninlärningsalgoritmer är att lägga till en extra parameter till inlärningsalgoritmens minimeringsproblem. Som ett exempel, betrakta fallet med övervakad inlärning av en linjär kombination av en uppsättning av $n$ kärnor $K$ . Vi introducerar en ny kärna ${\displaystyle K'=\sum _{i=1}^{n}\beta _{i}K_{i}} ,$ där ${ \displaystyle \beta }$ är en vektor av koefficienter för varje kärna. Eftersom kärnorna är additiv (på grund av egenskaperna för att reproducera kärnan Hilbert spaces ), är denna nya funktion fortfarande en kärna. För en uppsättning data $X$ med etiketter $Y$ kan minimeringsproblemet sedan skrivas som

$\min _{\beta ,c}\mathrm {E} (Y,K'c)+R(K,c)$

där $\mathrm {E}$ är en felfunktion och $R$ är en regulariseringsterm. $\mathrm {E}$ är typiskt fyrkantsförlustfunktionen ( Tikhonov regularization ) eller gångjärnsförlustfunktionen (för SVM -algoritmer), och $R$ är vanligtvis en $\ell _{ n}$ norm eller någon kombination av normerna (dvs elastisk nettoreglering ) . Detta optimeringsproblem kan sedan lösas med vanliga optimeringsmetoder. Anpassningar av befintliga tekniker såsom Sequential Minimal Optimization har också utvecklats för flera kärna SVM-baserade metoder.

Övervakat lärande

För övervakat lärande finns det många andra algoritmer som använder olika metoder för att lära sig kärnans form. Följande kategorisering har föreslagits av Gonen och Alpaydın (2011)

Fasta regler närmar sig

Fasta reglermetoder som den linjära kombinationsalgoritmen som beskrivs ovan använder regler för att ställa in kombinationen av kärnorna. Dessa kräver inte parametrering och använder regler som summering och multiplikation för att kombinera kärnorna. Viktningen lärs in i algoritmen. Andra exempel på fasta regler inkluderar parvisa kärnor, som är av formen

$k((x_{1i},x_{1j}),(x_{2i},x_{2j}))=k(x_{1i} ,x_{2i})k(x_{1j},x_{2j})+k(x_{1i},x_{2j})k(x_{1j},x_{2i})$ .

Dessa parvisa tillvägagångssätt har använts för att förutsäga protein-protein-interaktioner.

Heuristiska tillvägagångssätt

Dessa algoritmer använder en kombinationsfunktion som är parametriserad. Parametrarna är generellt definierade för varje enskild kärna baserat på prestanda med en kärna eller någon beräkning från kärnmatrisen. Exempel på dessa inkluderar kärnan från Tenabe et al. (2008). Låta $\pi _{m}$ vara den noggrannhet som erhålls med endast ${\displaystyle K_{m}} ,$ och låta $\delta$ vara ett tröskelvärde som är mindre än minimum av enkel- kärnnoggrannhet kan vi definiera

$\beta _{m}={\frac {\pi _{m}-\delta }{\sum _{h=1 }^{n}(\pi _{h}-\delta )}}$

Andra tillvägagångssätt använder en definition av kärnlikhet, som t.ex

$A(K_{1},K_{2})={\frac { \langle K_{1},K_{2}\rangle }{\sqrt {\langle K_{1},K_{1}\rangle \langle K_{2},K_{2}\rangle }}}$

Med detta mått använde Qui och Lane (2009) följande heuristik för att definiera

$\beta _{m}={\frac {A(K_{m},YY^{ T})}{\summa _{h=1}^{n}A(K_{h},YY^{T})}}$

Optimering närmar sig

Dessa tillvägagångssätt löser ett optimeringsproblem för att bestämma parametrar för kärnkombinationsfunktionen. Detta har gjorts med likhetsmått och strukturell riskminimering. För likhetsmått som det som definierats ovan kan problemet formuleras på följande sätt:

$\max _{\beta ,\operatörsnamn {tr} (K'_{tra})=1,K'\geq 0}A(K'_{tra},YY^{T}).$

där $K'_{tra}$ är kärnan i träningsuppsättningen.

för strukturell riskminimering som har använts inkluderar linjära tillvägagångssätt, såsom de som används av Lanckriet et al. (2002). Vi kan definiera osannolikheten för en kärna $\omega (K)$ för att vara värdet av objektivfunktionen efter att ha löst ett kanoniskt SVM-problem. Vi kan då lösa följande minimeringsproblem:

$\min _{\operatörsnamn {tr} (K'_{tra})=c}\omega (K'_{ tra})$

där $c$ är en positiv konstant. Många andra varianter finns på samma idé, med olika metoder för att förfina och lösa problemet, t.ex. med icke-negativa vikter för enskilda kärnor och användande av icke-linjära kombinationer av kärnor.

Bayesian närmar sig

Bayesiska tillvägagångssätt sätter priors på kärnparametrarna och lär sig parametervärdena från priors och basalgoritmen. Till exempel kan beslutsfunktionen skrivas som

$f(x)=\summa _{i=0}^{n}\alpha _{i}\summa _{m=1}^{p}\eta _{m}K_{m}(x_{i}^{m},x^{m})$

$\eta$ kan modelleras med en Dirichlet prior och $\alpha$ kan modelleras med en noll-medelvärde för Gauss och en invers gammavarians prior. Denna modell optimeras sedan med hjälp av en anpassad multinomial probit- metod med en Gibbs-sampler .

Dessa metoder har använts framgångsrikt i tillämpningar såsom proteinvecksigenkänning och proteinhomologiproblem

Boostande tillvägagångssätt

Ökningsmetoder lägger till nya kärnor iterativt tills några stoppkriterier som är en funktion av prestanda uppnås. Ett exempel på detta är MARK-modellen utvecklad av Bennett et al. (2002)

$f(x)=\summa _{i=1}^{N} \summa _{m=1}^{P}\alpha _{i}^{m}K_{m}(x_{i}^{m},x^{m})+b$

Parametrarna $\alpha _{i}^{m}$ och $b$ lärs in genom gradientnedstigning på koordinatbasis. På detta sätt identifierar varje iteration av nedstigningsalgoritmen den bästa kärnkolumnen att välja vid varje särskild iteration och lägger till den till den kombinerade kärnan. Modellen körs sedan om för att generera de optimala vikterna $\alpha _{i}$ och $b$ .

Halvövervakat lärande

Halvövervakade inlärningsmetoder för inlärning av flera kärnor liknar andra förlängningar av tillvägagångssätt för övervakat lärande. En induktiv procedur har utvecklats som använder en log-sannolikhet empirisk förlust och grupp LASSO-regularisering med villkorad förväntanskonsensus om omärkta data för bildkategorisering. Vi kan definiera problemet på följande sätt. Låt $L={(x_{i},y_{i})}$ vara märkta data, och låt $U={x_{i} }$ vara uppsättningen omärkta data. Sedan kan vi skriva beslutsfunktionen enligt följande.

$f(x)=\alpha _{0}+\sum _{i=1}^{|L|}\alpha _{i}K_{i}(x)$

Problemet kan skrivas som

$\min _{f}L(f)+\lambda R(f)+\gamma \Theta (f)$

där $L$ är förlustfunktionen (viktad negativ log-sannolikhet i detta fall), $R$ är regulariseringsparametern ( grupp LASSO i detta fall), och $\Theta$ är villkorlig förväntad konsensus (CEC) straff för omärkta data. CEC-straffet definieras enligt följande. Låt den marginella kärndensiteten för all data vara

$g_{m}^{\pi }(x)=\langle \phi _{m}^{\pi },\psi _{m}(x)\rangle$

där ${\displaystyle \psi _{m}(x)=[K_{m}(x_{ 1},x),\ldots ,K_{m}(x_{L},x)]^{T}} (kärnavståndet$ mellan märkta data och alla märkta och omärkta data) och ${\ displaystyle \phi _{m}^{\pi }}$ är en icke-negativ slumpmässig vektor med en 2-norm på 1. Värdet på $\Pi$ är antalet gånger varje kärna projiceras. Förväntningsregularisering utförs sedan på MKD, vilket resulterar i en referensförväntning $q_{m}^{pi}(y|g_{m}^{\pi }(x))$ och modellförväntningar $p_{m}^{\pi }(f(x)|g_{m}^{\ pi }(x))$ . Sedan definierar vi

$_ \displaystyle \Theta ={\frac {1}{\Pi }}\sum _{\pi =1}^{\Pi }\summa _{m=1}^{M}D(q_{m}^{ pi}(y|g_{m}^{\pi}(x))||p_{m}^{\pi }(f(x)|g_{m}^{\pi }(x)))}$

där $D(Q||P)=\summa _{i}Q(i)\ln {\ frac {Q(i)}{P(i)}}$ är Kullback-Leibler-divergensen . Det kombinerade minimeringsproblemet optimeras med hjälp av en modifierad blockgradientnedstigningsalgoritm. För mer information, se Wang et al.

Oövervakat lärande

Oövervakade inlärningsalgoritmer för flera kärnor har också föreslagits av Zhuang et al. Problemet definieras enligt följande. Låt $U={x_{i}}$ vara en uppsättning omärkta data. Kärndefinitionen är den linjära kombinerade kärnan $K'=\sum _{i=1}^{M}\beta _{i}K_{m}$ . I det här problemet måste data "klustras" i grupper baserat på kärnavstånden. Låt $B_{i}$ vara en grupp eller ett kluster där $x_{i}$ är en medlem. Vi definierar förlustfunktionen som $\sum _{i=1}^{n}\left \Vert x_{i}-\summa _{x_{j}\in B_{i}}K(x_{i},x_{j})x_{j}\right\Vert ^{2}$ . Dessutom minimerar vi distorsionen genom att minimera $\sum _{i=1}^{n} \summa _{x_{j}\in B_{i}}K(x_{i},x_{j})\left\Vert x_{i}-x_{j}\right\Vert ^{2}$ . Slutligen lägger vi till en regleringsterm för att undvika överanpassning. Genom att kombinera dessa termer kan vi skriva minimeringsproblemet enligt följande.

$\min _{\beta ,B}\sum _{i=1}^{n}\left\Vert x_{i}-\summa _{x_{j}\in B_{i}}K( x_{i},x_{j})x_{j}\right\Vert ^{2}+\gamma _{1}\summa _{i=1}^{n}\summa _{x_{j}\ i B_{i}}K(x_{i},x_{j})\left\Vert x_{i}-x_{j}\right\Vert ^{2}+\gamma _{2}\summa _{ i}|B_{i}|$

var . En formulering av detta definieras enligt följande. Låt $D\in {0,1}^{n\times n}$ vara en matris så att $D_{ij}=1$ betyder att $x_{i}$ och $x_{j}$ är grannar. Sedan, $B_{i}={x_{j}:D_{ij}=1}$ . Observera att dessa grupper också måste läras in. Zhuang et al. lös detta problem med en alternerande minimeringsmetod för $K$ och grupperna $B_{i}$ . För mer information, se Zhuang et al.

Bibliotek

Tillgängliga MKL-bibliotek inkluderar

• SPG-GMKL : Ett skalbart C++ MKL SVM-bibliotek som kan hantera en miljon kärnor.
• GMKL : Generalized Multiple Kernel Learning-kod i MATLAB , gör $\ell _{1}$ och $\ell _{2}$ regularisering för övervakat lärande.
• (En annan) GMKL : En annan MATLAB MKL-kod som också kan utföra elastisk nettoreglering
• SMO-MKL : C++-källkod för en MKL-algoritm för sekventiell minimal optimering. Gör $p$ -n orm regularisering.
• SimpleMKL : En MATLAB-kod baserad på SimpleMKL-algoritmen för MKL SVM.
• MKLPy : Ett Python-ramverk för MKL och kärnmaskiner som är scikit-kompatibelt med olika algoritmer, t.ex. EasyMKL och andra.