Jag antar att vi pratar om återkommande neurala nät (RNN) som producerar en utgång i varje gång (om utdata bara är tillgängligt i slutet av sekvensen är det bara meningsfullt att köra backprop i slutet) . RNN i denna inställning tränas ofta med hjälp av trunkerad backpropagation through time (BPTT), som fungerar sekventiellt på 'bitar' i en sekvens. Proceduren ser ut så här:

1. Vidarebefordra: Gå igenom nästa $ k_1 $ tidssteg, beräkna ingångs-, dolda och utdatatillstånden.
2. Beräkna förlusten, summerad över de tidigare tidstegen (se nedan).
3. Bakåtpass: Beräkna förlustens lutning alla parametrar som ackumuleras över de tidigare $ k_2 $ tidsstegen (detta kräver att du har lagrat alla aktiveringar för dessa tidssteg). Klipp lutningar för att undvika det exploderande lutningsproblemet (händer sällan).
4. Uppdatera parametrar (detta inträffar en gång per bit, inte stegvis i varje gång).
5. Om du bearbetar flera bitar av en längre sekvens, lagra det dolda tillståndet vid det senaste steget (kommer att användas för att initialisera dolt tillstånd för början av nästa bit). Om vi ​​har nått slutet av sekvensen, återställ minnet / dolt tillstånd och flytta till början av nästa sekvens (eller början av samma sekvens, om det bara finns en).
6. Upprepa från steg 1.

Hur förlusten summeras beror på $ k_1 $ och $ k_2 $. Till exempel när $ k_1 = k_2 $ summeras förlusten över de senaste $ k_1 = k_2 $ tidsstegen, men proceduren är annorlunda när $ k_2 > k_1 $ (se Williams och Peng 1990).

Gradientberäkning och uppdateringar utförs varje $ k_1 $ tidssteg eftersom det är beräkningsmässigt billigare än att uppdatera varje gång. Uppdatering flera gånger per sekvens (dvs. ställa in $ k_1 $ mindre än sekvenslängden) kan påskynda träningen eftersom viktuppdateringar är vanligare.

Backpropagation utförs endast för $ k_2 $ tidssteg eftersom det är beräkningsmässigt billigare än att sprida sig tillbaka till början av sekvensen (vilket kräver lagring och upprepad bearbetning av alla tidssteg). Gradienter som beräknas på detta sätt är en approximation till den "sanna" gradienten som beräknas över alla tidssteg. Men på grund av det försvinnande gradientproblemet tenderar lutningar att närma sig noll efter ett antal tidssteg; förökning över denna gräns skulle inte ge någon fördel. Att ställa in $ k_2 $ för kort kan begränsa den tidsskala som nätverket kan lära sig över. Nätverkets minne är dock inte begränsat till tidssteg på $ k_2 $ eftersom de dolda enheterna kan lagra information efter denna period (t.ex. se Mikolov 2012 och detta inlägg).

Dessutom beräkningsöverväganden, de rätta inställningarna för $ k_1 $ och $ k_2 $ beror på datastatistiken (t.ex. den tidsmässiga skalan för de strukturer som är relevanta för att producera bra resultat). De beror förmodligen också på detaljerna i nätverket. Det finns till exempel ett antal arkitekturer, initialiseringstrick etc. som är utformade för att lindra det förfallande gradientproblemet.

Ditt alternativ 1 ("ram-visande bakgrund") motsvarar att du ställer in $ k_1 $ till $ 1 $ och $ k_2 $ till antalet tidssteg från början av meningen till aktuell punkt. Alternativ 2 ('meningsmässig bakgrund') motsvarar att både $ k_1 $ och $ k_2 $ ställs in till meningslängden. Båda är giltiga tillvägagångssätt (med beräknings- / prestationsöverväganden som ovan; nummer 1 skulle vara ganska beräkningsintensivt för längre sekvenser). Ingen av dessa tillvägagångssätt skulle kallas "trunkerad" eftersom backpropagation sker över hela sekvensen. Andra inställningar på $ k_1 $ och $ k_2 $ är möjliga; Jag listar några exempel nedan.

Referenser som beskriver avkortad BPTT (procedur, motivation, praktiska frågor):

• Sutskever (2013). Utbildning av återkommande neurala nätverk.
• Mikolov (2012). Statistiska språkmodeller baserade på neurala nätverk.
  • Med vanilj-RNN för att bearbeta textdata som en ordsekvens rekommenderar han att du ställer in $ k_1 $ till 10-20 ord och $ k_2 $ till 5 ord
  • Utför flera uppdateringar per sekvens ( dvs $ k_1 $ mindre än sekvenslängden) fungerar bättre än att uppdatera i slutet av sekvensen
  • Att utföra uppdateringar en gång per bit är bättre än stegvis (vilket kan vara instabilt)
• Williams och Peng (1990). En effektiv gradientbaserad algoritm för onlineträning av återkommande nätverksbanor.
  • Algoritmens ursprungliga (?) förslag
  • De diskuterar valet av $ k_1 $ och $ k_2 $ (som de kallar $ h '$ och $ h $). De överväger bara $ k_2 \ ge k_1 $.
  • Obs: De använder frasen "BPTT (h; h ')" eller "den förbättrade algoritmen" för att hänvisa till vad de andra referenserna kallar "trunkerad BPTT". De använder frasen "trunkerad BPTT" för att betyda specialfallet där $ k_1 = 1 $.

Andra exempel som använder trunkerad BPTT:

• (Karpathy 2015). char-rnn.
  • Beskrivning och kod
  • Vanilj RNN behandlar textdokument ett tecken i taget. Tränad att förutsäga nästa karaktär. $ k_1 = k_2 = 25 $ tecken. Nätverk som används för att generera ny text i stil med träningsdokumentet, med roliga resultat.
• Graves (2014). Genererar sekvenser med återkommande neurala nätverk.
  • Se avsnittet om att generera simulerade Wikipedia-artiklar. LSTM-nätverk bearbetar textdata som sekvens av byte. Tränad att förutsäga nästa byte. $ k_1 = k_2 = 100 $ byte. LSTM-minne återställs var 10 000 $ byte.
• Sak et al. (2014). Långt korttidsminnesbaserade återkommande neurala nätverksarkitekturer för stort taligenkänning.
  • Modifierade LSTM-nätverk, bearbetar sekvenser av akustiska funktioner. $ k_1 = k_2 = 20 $.
• Ollivier et al. (2015). Träna återkommande nätverk online utan backtracking.
  • Poängen med denna uppsats var att föreslå en annan inlärningsalgoritm, men de jämförde den med trunkerad BPTT. Används vanilj-RNN för att förutsäga sekvenser av symboler. Bara nämner det här för att säga att de använde $ k_1 = k_2 = 15 $.
• Hochreiter och Schmidhuber (1997). Långt korttidsminne.
  • De beskriver ett modifierat förfarande för LSTM