Kompressiva neurala nät är ett aktivt forskningsproblem, med tanke på den stora storleken på toppmoderna nät för uppgifter som objektigenkänning, och de beräkningsbegränsningar som införs av mobila enheter. Vi ger en allmän formulering av modellkompression som begränsad optimering. Detta inkluderar många typer av komprimering: quantization, låg-rank sönderfall, beskärning, förlustfri komprimering och andra. Sedan ger vi en allmän algoritm för att optimera detta icke-konvexa problem baserat på den förstärkta Lagrangian och alternerande optimering. Detta resulterar i en "learning-compression" algoritm, som alternerar ett inlärningssteg av den okomprimerade modellen, oberoende av komprimeringstyp, med ett komprimeringssteg av modellparametrarna, oberoende av inlärningsuppgiften. Denna enkla, effektiva algoritm är garanterad att hitta den bästa komprimerade modellen för uppgiften i lokal bemärkelse under standardantaganden. Vi presenterar separat i flera följedokument utvecklingen av detta allmänna ramverk till specifika algoritmer för modellkomprimering baserad på kvantisering, beskärning och andra variationer, inklusive experimentella resultat på komprimera neurala nät och andra modeller. Stora neurala nätverksmodeller har blivit en central komponent i toppmoderna praktiska implementationer av lösningen till olika maskininlärning och artificiell intelligens problem. Dessa inkluderar till exempel klassificeringsproblem som rör bilder, ljud eller text, eller förstärka inlärningsproblem som gäller spel eller robotmanipulering och navigering. Detta har också resulterat i en enorm ökning av intresset för djupa neurala nätmodeller från forskare inom akademi och industri, och även från icke-experter och allmänheten i allmänhet, vilket framgår av mängden vetenskapliga artiklar, blogginlägg eller vanliga medieartiklar som publicerats om det. Dessa praktiska framgångar i svåra problem har uppstått tack vare tillgången till storskaliga dataset och den massiva beräkningskraft som tillhandahålls av GPU, som är särskilt väl lämpade för den typ av linjär algebra operationer som deltar i utbildning av ett neuralt nät (såsom stokastisk lutning nedstigning). En anmärkningsvärd egenskap hos djupa neurala nät som verkar skilja dem från andra maskininlärning modeller är deras förmåga att växa med data. Det vill säga, eftersom storleken på träningssetet växer, kan vi fortsätta att öka (säg) klassificering noggrannheten genom att öka storleken på det neurala nätet (antal dolda enheter och lager, och därmed antalet vikter). Detta är till skillnad från till exempel en linjär modell, vars klassificeringsnoggrannhet snabbt stagnerar när uppgifterna fortsätter att växa. Därför kan vi fortsätta att förbättra noggrannheten i ett neuralt nät genom att göra det större och utbildning på mer data. Detta innebär att vi kan förvänta oss att se allt större neurala nät i framtida praktiska tillämpningar. Modeller som rapporterats i litteraturen om datorseende har faktiskt gått från mindre än en miljon vikter på 1990-talet till miljoner på 2000-talet och, i de senaste verken, till modeller som överstiger miljarder vikter (var och en ett flyttalvärde). Den stora storleken på den resulterande modellen orsakar ett viktigt praktiskt problem när man avser att distribuera den i en resursbegränsad målenhet som en mobiltelefon eller andra inbyggda system. Den 1 är, det stora neurala nätet är utbildad i en resursrik miljö, t.ex. GPU och en flerkärnig arkitektur med stort minne och disk, där modelldesignern kan utforska olika modellarkitekturer, hyperparametervärden etc. tills en modell med den bästa noggrannheten på en valideringsuppsättning har hittats. Denna slutliga, stora modell är då redo att användas i praktiken. Målenheten kommer dock vanligtvis att ha betydligt mer restriktiva beräkningsbegränsningar i minne storlek och hastighet, aritmetiska operationer, klockfrekvens, energiförbrukning, etc., vilket gör det omöjligt att rymma den stora modellen. Med andra ord kan vi bara använda modeller av en viss storlek. Nedladdningsbandbredden är också avsevärt begränsad i appar för mobiltelefoner eller programvara för bilar. Detta problem har fått stor uppmärksamhet på senare tid. Två viktiga fakta väger tungt på det som har varit känt under en tid bland forskare. Den första är att de stora neurala nät som vi för närvarande vet hur man tränar för optimal noggrannhet innehåller betydande redundans, vilket gör det möjligt att hitta mindre neurala nät med jämförbar noggrannhet. Den andra är att man, av orsaker som inte är helt förstådda, vanligtvis uppnår en mer exakt modell genom att träna en stor modell först och sedan på något sätt omvandla den till en mindre ("komprimera" modellen), än genom att träna en liten modell i första hand. Detta leder oss till problemet med att komprimera ett neuralt nät (eller annan modell), som är vårt fokus. Kompressiva neurala nät har på senare år erkänts som ett viktigt problem och olika akademiska och industriella forskningsgrupper har visat att man verkligen kan komprimera neurala nät betydligt utan märkbara förluster i noggrannhet (se relaterade arbete nedan). De lösningar som hittills har föreslagits är dock något ad hoc-lösningar i två avseenden. Först definierar de en specifik komprimeringsteknik (och en specifik algoritm för att hitta den komprimerade modellen) som kan fungera bra med vissa typer av modeller men inte andra. För det andra är vissa av dessa lösningar inte garanterade att vara optimala i den bemärkelsen att uppnå den högsta klassificeringsnoggrannheten för den kompressionsteknik som beaktas. I detta dokument ger vi en allmän formulering av modellkompression och en träningsalgoritm för att lösa det. Formuleringen kan rymma alla komprimeringsteknik så länge den kan sättas i en viss matematisk form, vilket inkluderar de flesta befintliga tekniker. Kompressionsmekanismen visas som en svart låda, så att algoritmen helt enkelt itererar mellan att lära sig en stor modell och komprimera den, men garanteras att konvergera till en lokalt optimal komprimerad modell under vissa standardantaganden. I separata uppsatser utvecklar vi specifika algoritmer för olika komprimeringsformer, såsom kvantisering (Carreira-Perpiñán och Idelbayev, 2017a) eller beskärning (Carreira-Perpiñán och Idelbayev, 2017b), och utvärderar dem experimentellt. I resten av detta dokument diskuterar vi relaterade arbeten (avsnitt 2), ger den generiska formuleringen (avsnitt 3) och den generiska LC-algoritmen (avsnitt 4), ger förutsättningar för konvergens (avsnitt 5) och diskuterar relationen mellan vår LC-algoritm och andra algoritmer (avsnitt 6) och relationen med generalisering och modellval (avsnitt 7). Generellt sett kan vi förstå modellkompression som att ersätta en "stor" modell med en "liten" modell inom ramen för en given uppgift, och detta kan göras på olika sätt. Låt oss diskutera fastställandet av det problem som motiverar behovet av kompression. Anta att vi definierar maskininlärningsuppgiften som klassificering för objektigenkänning från bilder och betrakta som stor modell f (x; w): X → Y ett djupt neuralt nät med ingångar x  på X (bilder), utgångar y  på Y (objektklassetiketter) och real-värderade vikter w  och R P (där antalet vikter P är stort). För att träna en modell använder vi en förlust L(), t.ex. kors-entropi på en stor utbildning uppsättning input-output par (x n, y n ). Anta också att vi har tränat ett stort, referens neuralt nät f (x; w), d.v.s. w = arg min w L(f; w)), och att vi är nöjda med dess prestanda i form av noggrannhet, men dess storlek är för stor. Vi vill nu ha en mindre modell h(x;): X → Y som vi kan tillämpa på samma uppgift (klassificera indatabilder x i etiketter y). Hur ska vi definiera denna mindre modell? En möjlighet är att den lilla modellen h(x; ) är av samma typ som referensmodellen f men omparameteriserad i termer av en lågdimensionell parametervektor. Det vill säga, vi konstruerar vikter som är mindre än storleken på w, dvs Q < P (t.ex., detta kommer att begränsa den möjliga w  och R P som kan konstrueras). I exemplet tidigare, h(x;  på) skulle vara samma djupa nätet men, låt oss säga, med viktvärden w =  på ( på) kvantifieras med hjälp av en kodbok med K poster (så  på innehåller kodboken och tilldelningen av varje vikt w i till en kodbok post). En andra möjlighet 2 är att den lilla modellen h(x; ) ska vara en helt annan typ av modell än referensen, t.ex. en linjär kartläggning med parametrar  på (så det finns inget samband mellan w och  på). Med tanke på detta har vi följande alternativ för att konstruera den lilla modellen h(x;  ska): • Direktinlärning: min  på L(h(x; )): hitta den lilla modellen med den bästa förlusten oavsett referens. Det vill säga, helt enkelt träna den lilla modellen för att minimera förlusten direkt, eventuellt med hjälp av kedjeregeln för att beräkna lutningen wrt  på. Detta approximerar referensmodellen indirekt, genom att både f och h försöker lösa samma uppgift. Vi kan ha den lilla modellen h vara en reparameteriserad version av f eller en helt annan modell. Direkt inlärning är det bästa man kan göra ibland, men inte alltid, vilket konstateras senare. • Direkt kompression (DC): min  till w −  och 2 : hitta närmaste approximation till referensmodellens parametrar, med hjälp av en lågdimensionell parameterisering. Detta tvingar h och f att vara modeller av samma typ. Direkt kompression kan helt enkelt göras med (förlustlös eller förlust) kompression av w, men det i allmänhet inte kommer att vara optimal wrt förlusten eftersom den senare ignoreras i lärande  på. Vi diskuterar detta senare i detalj. • Modellkompression som begränsad optimering: detta är vårt föreslagna tillvägagångssätt, som vi beskriver i avsnitt 3. Det tvingar h och f att vara modeller av samma typ, genom att begränsa vikterna w som ska konstrueras från en låg-dimensionell parameterisering w =  på ( på), men h måste optimera förlusten L. • Lärare-student : min  på X p(x) f (x; w) − h(x;  på) 2 dx: hitta närmaste approximation h till referensfunktionen f, i vissa norm. Normen över domänen X kan approximeras med ett prov (t.ex. Utbildningssetet). Här kan referensmodellen f "teaches" studentmodellen h. Vi kan ha den lilla modellen h vara en reparameteriserad version av f eller en helt annan modell. De flesta befintliga komprimeringsmetoder faller inom en av dessa kategorier. I synnerhet, traditionella kompression tekniker har tillämpats med hjälp av tekniker mest relaterade till direkt utbildning och direkt kompression: använda lågprecision vikt representationer genom någon form av avrundning (se Gupta et al., 2015; Huvara et al., 2016 och referenser däri), även enkel-bit (binary) värden (Fiesler et al., 1990; Courbariaux et al., 2015; Rastegari et al., 2016; Huvara et al., 2016; Zhou et al., 2016), ternära värden (Hwang och Sung, 2014; Li et al., 2016; Zhu et al., 2017) eller befogenheter två (Marchesi et al., 1993; Tang och Kwan, 1993) ; kvantisering av viktvärden, mjuk (Nowlan och Hinton, 1992; Ullrich et al., 2017) eller hård (Fiesler et al., 1990; Marchesi et al., 1993; Gong et al., 2015) ; quantization av viktvärden, mjuk (Nowlan och Hint. Vissa tidningar kombinerar flera sådana tekniker för att producera imponerande resultat, t.ex. Han och Al. (2016) Använd beskärning, utbildad kvantisering och Huffman-kodning. Även om vi kommenterar några av dessa arbeten i detta dokument (särskilt när det gäller den direkta komprimeringsmetoden), skjuter vi upp detaljerade diskussioner till våra följedokument om specifika kompressionstekniker (kvantisering i Carreira-Perpiñán och Idelbayev, 2017a och beskärning i Carreira-Perpiñán och Idelbayev, 2017b, hittills). Lärar- och studenttänkandet verkar ha uppstått i ensembleinlärningslitteraturen, inspirerad av önskan att ersätta en stor ensemblemodell (t.ex. en samling beslutsträd), som kräver stor lagring och är långsam vid testtillfället, med en mindre eller snabbare modell med liknande klassificeringsnoggrannhet (Zhou, 2012, avsnitt 8.5). Den mindre modellen kan vara av samma typ som ensemblemedlemmarna, eller en annan typ av modell helt och hållet (t.ex. ett neuralt nät). Grundidén är, efter att ha tränat den stora ensemblen på ett märkt träningsset, att använda denna ensemble ("läraren") för att märka en större, omärkt dataset (som kan finnas i den aktuella uppgiften, eller kan genereras genom någon form av provtagning). Denna större, märkta datauppsättning används sedan för att träna den mindre modellen ("studenten"). Förhoppningen är att den kunskap som infångas av läraren är tillräckligt representerad i det syntetiskt skapade träningssetet (även om lärarens misstag också kommer att finnas representerade i det), och att studenten kan lära sig det väl även om det är en mindre modell. Mer allmänt kan metoden tillämpas med vilken lärare som helst, inte nödvändigtvis en ensemblemodell (t.ex. Ett djupt nät), och lärarens etiketter kan omvandlas för att förbättra elevens lärande, t.ex. log-outputs (Ba och Caruana, 2014) eller andra manipulationer av utdataklassen sannolikheter (Hinton et al., 2015). Men ur en kompression 3 synvinkel resultaten är oimpressiva, med blygsamma kompressionsförhållanden (Hinton et al., 2015) eller till och med misslyckande att komprimera (med hjälp av ett enskiktsnät som student behöver många fler vikter än läraren djupt nät; Ba och Caruana, 2014). Ett praktiskt problem med lärar-student-metoden är att allt den verkligen gör är att konstruera det konstgjorda träningssetet, men det lämnar designen av studenten till användaren, och detta är ett svårt modellvalsproblem. Detta skiljer sig från de komprimeringsmetoder som nämns ovan, som använder lärarens modellarkitektur men komprimerar dess parametrar. I detta arbete förstår vi kompression i matematiskt specifik mening som innebär en inlärningsuppgift som vi vill lösa och en stor modell som anger referensen att möta. Det är relaterat till de direkta utbildnings- och komprimeringskoncept som införts ovan. Anta att vi har en stor referensmodell f (x; w) med P-parametrar (t.ex. ett neuralt nät med ingångar x och vikter w  på R P ) som har tränats på en förlust L () (t.ex. korsentropi på ett givet träningsset) för att lösa en uppgift (t.ex. Klassificering. Det vill säga w = arg min w L(w), där vi missbrukar notationen för att skriva förlusten direkt över vikterna snarare än L (f (x; w)), och minimering w kan vara lokal. Vi definierar kompression som att hitta en lågdimensionell parameterisering av w i termer av Q < P-parametrar. Detta kommer att definiera en komprimerad modell h(x;  på) = f (x;  på)). Vi söker en sådan att dess motsvarande modell har (lokalt) optimal förlust. Vi betecknar detta "optimala komprimerade" och skriver det som.. * och w *..... (.. * ) (se fig. 1 )............................................................................................................... Vanligtvis skulle man då kunna lösa problemet direkt över:  på * = arg min  på L( på)). Detta är det direkta inlärningsalternativet i föregående avsnitt. Istället skriver vi motsvarande modellkompression som ett begränsat optimeringsproblem: min Anledningen, som kommer att vara användbar senare för att utveckla en optimeringsalgoritm, är att vi frikopplar den del av lärandet uppgiften, L(w) i målet, från den del av komprimerande modellen, w =  på grund av begränsningar.
Mycket arbete finns på komprimera neurala nät, med kvantisering, låg-rank sönderfall, beskärning och andra tekniker, se REF och referenser där.
Model compression as constrained optimization, with application to neural nets. Part I: general framework
{'venue': 'ArXiv', 'journal': 'ArXiv', 'mag_field_of_study': ['Computer Science', 'Mathematics']}