Sdílet prostřednictvím

Odkazy na vrstvy pomocí BrainScriptu

CNTK předdefinuje řadu běžných "vrstev", což usnadňuje psaní jednoduchých sítí, které se skládají ze standardních vrstev vrstvených na sebe navzájem. Vrstvy jsou objekty funkcí, které lze použít jako běžné funkce BrainScriptu, ale obsahují naučitelné parametry a mají další dvojici {} předávat stavební parametry nebo atributy.

Jedná se například o popis sítě pro jednoduchý 1 skrytý model vrstvy pomocí této vrstvy DenseLayer{} :

h = DenseLayer {1024, activation=ReLU} (features)
p = DenseLayer {9000, activation=Softmax} (h)

které lze použít například pro trénování proti kritérium křížové entropie:

ce = CrossEntropy (labels, p)

Pokud je vaše síť rovnou zřetězením operací (mnoho z nich), můžete použít alternativu. Sequential() Zápis:

myModel = Sequential (
    DenseLayer {1024, activation=ReLU} :
    DenseLayer {9000, activation=Softmax}
)

a vyvolat ho takto:

p = myModel (features)

Ukázkové modely

Následující příklad ukazuje tagger slotu, který vloží posloupnost slov, zpracuje ji s opakujícím se LSTM a potom klasifikuje každé slovo:

taggingModel = Sequential (
    EmbeddingLayer {150} :      # embed into a 150-dimensional vector
    RecurrentLSTMLayer {300} :  # forward LSTM
    DenseLayer {labelDim}       # word-wise classification
)

A toto je jednoduchá konvoluční síť pro rozpoznávání obrázků:

convNet = Sequential (
    # 3 layers of convolution and dimension reduction by pooling
    ConvolutionalLayer {32, (5:5), pad=true, activation=ReLU} :
    MaxPoolingLayer {(3:3), stride=(2:2)} :
    ConvolutionalLayer {32, (5:5), pad=true, activation=ReLU} :
    MaxPoolingLayer {(3:3), stride=(2:2)} :
    ConvolutionalLayer {64, (5:5), pad=true, activation=ReLU} :
    MaxPoolingLayer {(3:3), stride=(2:2)} :
    # 2 dense layers for classification
    DenseLayer {64, activation=ReLU} :
    LinearLayer {10}
)

Sdílení parametrů

Pokud přiřadíte vrstvu proměnné a použijete ji na více místech, parametry se budou sdílet. Pokud řeknete

lay = DenseLayer {1024, activation=Sigmoid}
h1 = lay (x)
h2 = lay (h1)  # same weights as `h1`

h1 a h2bude sdílet stejné parametry, jako lay() je stejná funkce v obou případech. V předchozím případě to pravděpodobně není to, co bylo žádoucí, takže mějte na paměti. Pokud mají obě vyvolání lay() výše uvedené parametry mít různé parametry, nezapomeňte definovat dvě samostatné instance, například lay1 = DenseLayer{...} a lay2 = DenseLayer{...}.

Tak proč toto chování? Vrstvy umožňují sdílet parametry napříč oddíly modelu. Zvažte model DSSM, který zpracovává dva vstupní image, řekněme doc a query identicky se stejným řetězem zpracování, a porovnává výsledné skryté vektory:

imageToVec = Sequential (
    ConvolutionalLayer {32, (5:5), pad = true, activation = ReLU} :
    MaxPoolingLayer {(3:3), stride = (2:2)} :
    ConvolutionalLayer {64, (5:5), pad = true, activation = ReLU} :
    MaxPoolingLayer {(3:3), stride = (2:2)} :
    DenseLayer {64, activation = ReLU} :
    LinearLayer {10}
)
zDoc   = imageToVec (doc)
zQuery = imageToVec (query)  # same model as for zDoc
sim = CosDistance (zdoc, zQuery)

kde imageToVec je součástí modelu, který převádí obrázky na plochý vektor. imageToVec je objekt funkce, který zase obsahuje několik objektů funkce (např. tři instance ConvolutionalLayer{}). imageToVec vytvoří instanci jednou a tato instance obsahuje naučitelné parametry všech zahrnutých objektů funkce. Obě vyvolání model() budou tyto parametry sdílet v aplikaci a jejich přechody budou součet obou vyvolání.

Nakonec mějte na paměti, že pokud ve výše uvedeném příkladu query a doc musí mít stejné dimenze, protože jsou zpracovány prostřednictvím stejného objektu funkce a první vrstva objektu funkce má její vstupní dimenzi odvozenou tak, aby odpovídala dvěma query i doc. Pokud se jejich dimenze liší, je tato síť poškozená a odvození nebo ověření dimenze selže s chybovou zprávou.

Poznámka k implementaci

Mnoho vrstev jsou obálky kolem podkladových CNTK primitiv spolu s příslušnými požadovanými naučenými parametry. ConvolutionalLayer{} Například zabalí primitivuConvolution(). Výhody používání vrstev jsou:

  • vrstvy obsahují naučitelné parametry správné dimenze.
  • vrstvy jsou kompozovatelné (cf. Sequential())

Hustálayer{}, LinearLayer{}

Funkce továrny pro vytvoření plně připojené vrstvy DenseLayer{} přebírá nepovinnou nelineárníitu.

DenseLayer {outDim, activation=Identity, init='glorotUniform', initValueScale=1, bias=true}
LinearLayer {outDim, init='glorotUniform', initValueScale=1, bias=true}

Parametry

  • outDim: výstupní dimenze této vrstvy
  • activation (DenseLayer{} pouze): předejte funkci, která se má použít jako aktivační funkce, například activation=ReLU
  • init ('heNormal'|'glorotUniform'|...): typ inicializace pro váhy. Úplný seznam možností inicializace najdete tady.
  • initValueScale: rozptyl náhodné inicializace se vynásobí tímto
  • bias: pokud nepravda, nezahrnujte parametr předsudku.

Návratová hodnota

Funkce, která implementuje požadovanou plně připojenou vrstvu. Viz popis.

Description

Pomocí těchto funkcí továrny můžete vytvořit plně připojenou vrstvu. Použijte DenseLayer{} , pokud chcete, aby byla zahrnuta aktivační funkce, jinak LinearLayer{}.

Každá z těchto funkcí továrny vytvoří objekt funkce, který obsahuje naučitelnou matici hmotnosti, a pokud bias=falsese jedná o učitelné předsudky. Objekt funkce lze použít jako funkci, která implementuje jeden z těchto vzorců:

DenseLayer{...} (v) = activation (W * v + b)
LinearLayer{...} (v) = W * v + b

kde W je matice hmotnosti dimenze , b je předsudky dimenze [outDim x (dimension of v)][outdim]a výsledná hodnota má dimenzi (nebo tensorové dimenze), jak je uvedeno .outDim

Podpora tensoru

Pokud se vrácená funkce použije na vstup tensoru pořadí > 1, například 2D obrázek, W bude mít rozměr [outDim x (first dimension of input) x (second dimension of input) x ...].

Na druhé straně outDim může být vektor, který určuje rozměry tensoru, například (10:10). V takovém případě W bude mít dimenzi [outDim[0] x outDim[1] x ... x (dimension of input)]a b bude mít rozměry tensoru [outDim[0] x outDim[1] x ...].

CNTK maticový produkt interpretuje tyto nadbytečné výstupní nebo vstupní dimenze, jako by byly zploštěny do dlouhého vektoru. Další podrobnosti o tom najdete v dokumentaci Times()

Příklad:

h = DenseLayer {1024, activation=Sigmoid) (v)

nebo alternativně:

Layer = DenseLayer {1024, activation=Sigmoid)
h = Layer (v)

ConvolutionalLayer{}

Vytvoří konvoluční vrstvu s volitelnou nelinearitou.

ConvolutionalLayer {numOutputChannels, filterShape,
                    activation = Identity,
                    init = 'glorotUniform', initValueScale = 1,
                    stride = 1, pad = false, lowerPad = 0, upperPad = 0,
                    bias = true}

Parametry

  • numOutputChannels: počet výstupních kanálů (počet filtrů)
  • filterShape: prostorový rozsah filtru, například (5:5) pro 2D filtr. Dimenze vstupního kanálu není zde zahrnutá.
  • activation: nepovinná nelineárníita, např. activation=ReLU
  • init ('heNormal'|'glorotUniform'|...): typ náhodné inicializace pro váhy. Úplný seznam možností náhodné inicializace najdete tady.
  • initValueScale: rozptyl náhodné inicializace se vynásobí tímto
  • stride: Při posouvání filtru přes vstup se zvýší. Například (2:2) snížit rozměry o 2
  • pad: pokud není nastavena (výchozí), filtr se přesune přes "platnou" oblast vstupu, to znamená, že se nepoužívá žádná hodnota mimo oblast. Pokud pad je nastavený na druhou stranu, použije se filtr na všechny vstupní pozice a hodnoty mimo platnou oblast se považují za nula.
  • lowerPad, upperPad: explicitně zadejte různé okraje pro odsazení. Filtry se přesunou přes platnou oblast, která je (prakticky) rozšířena o nuly. Například lowerPad=(1:2) připojí sloupec nuly a dva řádky nuly. Rozměr výstupu se odpovídajícím způsobem rozšíří.
  • bias: pokud nepravda, nezahrnujte parametr předsudku.

Návratová hodnota

Funkce, která implementuje požadovanou plně připojenou vrstvu. Viz popis.

Description

Pomocí těchto funkcí továrny vytvořte konvoluční vrstvu.

Výsledná vrstva použije konvoluční operaci na N-dimenzionální tensor. Volající určuje prostorový rozšíření filtru. Sada filtrů daného prostorového rozsahu (např (5:5). ) se koreluje s každým umístěním vstupu (např. obrázkem [640 x 480]velikosti). Za předpokladu, že je povolené odsazení (pad) a kroky jsou 1, vygeneruje se výstupní oblast stejné dimenze ([640 x 480]).

Obvykle se používá mnoho filtrů najednou. numOutputChannels určuje číslo, takže pro každé vstupní umístění se vytvoří celý vektor numOutputChannels . V našem příkladu výše by nastavení numOutputChannels na 64 v tensoru [640 x 480 x 64]velikosti. Tato poslední osa se nazývá rozměr kanálu.

Při použití konvoluce na vstup s dimenzí kanálu se každý filtr bude skládat také z vektorů dimenze kanálu vstupu. Například při použití konvoluce se zadaným prostorovým filtrem na (5:5)[640 x 480 x 3]barevný obrázek velikosti bude každý filtr tensorem [5 x 5 x 3] .

Všechny numOutputChannels filtry skládané dohromady se nazývají jádro. V našem příkladu bude [5 x 5 x 3 x 64]tvar jádra .

Následující shrnutí vztahu mezi různými rozměry a obrazci:

input shape    : [ (spatial dims)  x  (#input channels)                        ]
spatial extent : [ (filterShape)                                               ]
output shape   : [ (spatial dims)  x                     x  numOutputChannels  ]
kernel shape   : [ (filterShape)   x  (#input channels)  x  numOutputChannels  ]

které v našem příkladu jsou:

input shape    : [ 640 x 480   x   3                          ]
spatial extent : [   5 x 5                                    ]
output shape   : [ 640 x 480   x       x   numOutputChannels  ]
kernel shape   : [   5 x 5     x   3   x   numOutputChannels  ]

Odsazení

Pokud odsazení není povolené, bude výstupní oblast omezena umístěními hranic, na které nelze použít úplný rozsah filtru. Například použití filtru rozsahu (5:5)na obrázek bez odsazení, vnější 2 řádky a sloupce pixelů by způsobily použití filtru mimo hranice. ConvolutionalLayer{} Proto se rozměry odpovídajícím způsobem zmenšují.

Obrázek [640 x 480] konvolvovaný s filtrem (5:5) bez odsazení ponechá [636 x 476]výstupní oblast velikosti.

Kroky

Parametry stride určují přírůstek filtrů. Hodnoty stride větší než jedna vedou k dílčímu vzorkování výstupní oblasti. Například filtrování obrázku [640 x 480] s rozsazením (2:2) bude mít [320 x 240]za následek oblast velikosti s odsazením a [318 x 238] bez odsazení.

Poznámky

Tato vrstva je obálka kolem primitivního Convolution() .

Název parametrů jádra filtru, jak je znázorněno v oddílu ověření protokolu, bude končit .W. Dimenze se v současné době nezobrazí tak, jak [ (filterShape) x (#input channels) x numOutputChannels ] je popsáno výše, ale místo toho [ numOutputChannels x (produkt přes obrazec filtru) * (#input kanály)) ]'.

Příklad:

c = ConvolutionalLayer {64, (3:3), pad = true, stride = (1:1), bias=false} (x)

DeconvLayer{}

Vytvoří dekonvoluční vrstvu.

DeconvLayer {numOutputChannels,
             filterShape, numInputChannels,
             bias = true,
             activation = (x=>x),
             init = 'glorotUniform',
             initValueScale = 0.001,
             initBias = 0,
             stride = 1, autoPadding = false,
             lowerPad = 0, upperPad = 0,
             maxTempMemSizeInSamples = 0}

Parametry

  • numOutputChannels: počet výstupních kanálů (počet filtrů)
  • filterShape: prostorový rozsah filtru, například (5:5) pro 2D filtr. Dimenze vstupního kanálu zde není zahrnuta.
  • numInputChannels: počet vstupních kanálů (počet filtrů vstupního svazku)
  • bias: pokud false, nezahrnujte parametr předsudku.
  • activation: nepovinná nelineárníita, např. activation=ReLU
  • init ('heNormal'|'glorotUniform'|...): typ náhodné inicializace pro váhy. Úplný seznam možností náhodné inicializace najdete tady.
  • initValueScale: Inicializace náhodné odchylky se vynásobí tímto
  • initBias: počáteční hodnota pro předsudky
  • stride: Zvýšení při posouvání filtru přes vstup. Například (2:2) snížit rozměry o 2
  • autoPadding: Pokud není nastavená (výchozí), filtr se posune přes "platnou" oblast vstupu, to znamená, že se nepoužívá žádná hodnota mimo oblast. Pokud autoPadding je nastavena na druhou stranu, použije se filtr na všechny vstupní pozice a hodnoty mimo platnou oblast budou považovány za nulu.
  • lowerPad, upperPad: explicitně zadejte různé okraje pro odsazení výstupního svazku, tj. ty, které byly použity pro vstup v odpovídající konvoluční vrstvě. Je důležité je nastavit v korespondenci s konvoluční vrstvou pro dosažení stejných rozměrů tensoru.

Návratová hodnota

Funkce, která implementuje požadovanou plně propojenou vrstvu. Viz popis.

Description

Pomocí těchto funkcí továrny můžete vytvořit dekonvoluční vrstvu.

Výsledná vrstva použije operaci dekonvoluce na N-dimenzionální tensor. Tato vrstva je obálka kolem primitivního Convolution() s deconv=true.

Jedním z oblíbených písmen použití pro dekonvoluci je rekonstrukce obrázku (viz například zde). Kde konvoluce přebírá vstupní 2D oblast receptivního pole a vypočítá korelaci s 2D filtrem, dekonvoluce vezme pixel a rozloží ji do 2D oblasti.

Představte si obrázek p(.,.), umístění v pixelech (x,y) a vycentrovaný filtr [3 x 3] s následujícím obsahem (žádný rozměr hloubky mapy funkcí, tj. jeden jeden kanál):

[ . . c
  a b .
  . . . ]

Tady, b a c jsou váhy filtru, '.' Odpovídá nulové hmotnosti. Konvolution() vypočítá výstupní pixel q(x, y) v umístění (x, y) jako:

q(x,y) = b * p(x,y) + a * p(x-1,y) + c * p(x+1,y-1)

Dekonvoluce přebírá pixely q(x;y) a rozprostírá je kolem oblasti (x,y). Pokud bychom použili stejný filtr, provedl by následující příspěvky do výstupu r(x;y):

r(x,y)     += b * q(x,y)
r(x-1,y)   += a * q(x,y)
r(x+1,y-1) += c * q(x,y)

S vědomím, že totéž platí pro všechny x a y v letadle, můžeme to vyjádřit pro r(x;y):

r(x,y)     += b * q(x,y)
r(x,y)     += a * q(x+1,y)
r(x,y)     += c * q(x-1,y+1)

nebo celkem,

r(x,y) = b * q(x,y) + a * q(x+1,y) + c * q(x-1,y+1)

To má stejný tvar jako Sousloví výše, s tím rozdílem, že filtr je zrcadlený podél obou os.

Nyní do mixu zavádíme mapy funkcí. To je snadné: Místo toho, abychom přešli ze vstupní hloubky do hloubky výstupu, přejdeme na jiný směr.

V souhrnu konvolution (W, x) == Deconvolution (W', x), kde

W : [W x H x C x K]

a

W’ = W s hodnotami, které jsou přeuspořádané jako: [(W mirrored) x (H mirrored) x K x C]

To, co Deconvolution() implicitně dělá, je:

  • výměna dvou rozměrů hloubky (transponovat)
  • prostorové dimenze (obrácené pořadí dat)
  • Convolution() s těmito

Příklad:

deconv_A = DeconvLayer {inputDim, (5:5), cMap1, lowerPad=(2:2:0), upperPad=(2:2:0)}(unpool_A)

Podrobný příklad najdete v tématu Automatický kodér obrázků pomocí dekonvoluce a zrušení zařazování .

MaxPoolingLayer{}, AveragePoolingLayer{}

Funkce továrny pro vytvoření maximální nebo průměrné vrstvy sdružování

MaxPoolingLayer {poolShape, stride = 1, pad = false, lowerPad = 0, upperPad = 0}
AveragePoolingLayer {poolShape, stride = 1, pad = false, lowerPad = 0, upperPad = 0} =

Parametry

  • poolShape: tvar oblasti pro fond, např. (2:2)
  • stride: zvýšení při posouvání fondu přes vstup. Například (2:2) snížit rozměry o 2
  • pad: Pokud není nastavená (výchozí), fond se posune přes "platnou" oblast vstupu, to znamená, že se nepoužívá žádná hodnota mimo oblast. Pokud pad je nastaven na druhou stranu, fond se použije na všechny vstupní pozice a hodnoty mimo platnou oblast se považují za nula. V případě průměrného sdružování nezahrnuje počet průměrovaných hodnot.
  • lowerPad, upperPad: explicitně zadejte různé okraje pro odsazení. Filtry se přesunou přes platnou oblast, která je (prakticky) rozšířena o nuly. Například lowerPad=(1:2) připojí sloupec s nulami a dvěma řádky nul. Rozměr výstupu se odpovídajícím způsobem rozšíří.

Návratová hodnota

Funkce, která implementuje požadovanou vrstvu sdružování. Viz popis.

Description

Tato funkce továrny slouží k vytvoření operace sdružování. Umožňuje MaxPoolingLayer{} vypočítat maximum nad hodnotami v oblasti fondu a AveragePoolingLayer{} vzít jejich průměr.

Operace sdružování posune "okno fondu" přes umístění vstupní oblasti a vypočítá maximální nebo průměr hodnot v příslušné oblasti fondu.

Tato operace je strukturálně velmi podobná konvoluci, s tím rozdílem, že operace použitá na posuvné okno je jiné povahy.

Všechny aspekty týkající se vstupních dimenzí, odsazení a kroků platí stejně, takže další podrobnosti najdete v tématu ConvolutionalLayer{} .

Příklad:

p = MaxPoolingLayer {(3:3), stride=(2:2)} (c)

MaxUnpoolingLayer{}

Vytvoří maximální vrstvu zrušení izolace.

MaxUnpoolingLayer {poolShape,
                   stride = 1, pad = false,
                   lowerPad = 0, upperPad = 0}

Parametry

  • poolShape: tvar oblasti pro zrušení zařazování (velikost výstupní oblasti), např. (2:2)
  • stride: zvýšení při posouvání fondu přes výstup. Například (2:2) zvýšit rozměry o 2
  • pad: Pokud není nastavená (výchozí), fond se posune přes "platnou" oblast výstupu, to znamená, že se nepoužívá žádná hodnota mimo oblast.
  • lowerPad, upperPad: explicitně zadejte různé okraje pro odsazení. Filtry budou předpokládat platnou výstupní oblast, která je (virtuálně rozšířená).

Návratová hodnota

Funkce, která implementuje požadovanou vrstvu zrušení zařazování. Viz popis.

Description

Tato funkce továrny slouží k vytvoření operace zrušení zařazování.

Operace zrušení zařazování je inverzní k operaci sdružování. Vyžaduje dva vstupy: výstup odpovídající vrstvy sdružování, například p1 vstup odpovídající vrstvy sdružování, například r1. Snímek "inverzního okna fondu" přes umístění vstupu p1a projektuje hodnotu na toto umístění výstupní oblasti, která měla maximální hodnotu v odpovídající operaci sdružování, tj. v r1. Druhý vstup r1 se vyžaduje v CNTK k určení cíle operace Zrušení zařazování, protože CNTK neukládá tzv. proměnné přepínače (podrobnosti najdete tady).

Příklad:

unpool_A = MaxUnpoolingLayer {(2:2), stride=(2:2)}(deconv_B, relu_A)

Podrobný příklad najdete v tématu Automatický kodér obrázků pomocí dekonvoluce a zrušení zařazování .

EmbeddingLayer{}

EmbeddingLayer {outDim,
                init='glorotUniform', initValueScale=1,
                embeddingPath = '', transpose = false}

Parametry

  • outDim: rozměr požadovaného vektoru vkládání
  • init ('heNormal'|'glorotUniform'|...): typ inicializace pro váhy. Úplný seznam možností inicializace najdete tady.
  • initValueScale: Inicializace náhodné odchylky se vynásobí tímto
  • embeddingPath: Pokud je to dané, vkládání se nenaučí, ale načte se ze souboru a během trénování se dále neaktualizuje.
  • transpose: umožňuje načíst vkládání, které jsou uloženy v transponované podobě.

Návratová hodnota

Funkce, která implementuje vrstvu vkládání. Viz popis.

Description

"Vkládání" odkazuje na reprezentaci slov nebo jiných diskrétních položek pomocí hustě souvislých vektorů. Tato vrstva předpokládá, že vstup je v jednorázové podobě. Například pro velikost slovníku 10 000 se očekává, že každý vstupní vektor bude mít rozměr 10 000 a skládá se z nul s výjimkou jedné pozice, která obsahuje 1. Index tohoto umístění je index slova nebo položky, které představuje.

V CNTK se odpovídající vektory vkládání ukládají jako sloupce matice. Mapování vstupního slova na vložení se proto implementuje jako maticový produkt. Aby to bylo velmi efektivní, je důležité, aby vstupní vektory byly uloženy ve řídkém formátu.

Zábavný fakt: Přechod matice vkládání má formu přechodových vektorů, které jsou pouze nenulové pro slova, která jsou vidět v minibatchu. Vzhledem k tomu, že pro realistické slovníky desítek nebo stovek tisíc by velká většina sloupců byla nula, CNTK implementuje specifickou optimalizaci, která představuje přechod ve formě "sloupcově zhuštěný".

Známý problém: Výše uvedený přechodový formulář se řídkým sloupcem v současné době nepodporuje naši 1bitovou metodou paralelizace SGD. Místo toho použijte metodu blokové dynamiky .

Příklad

Naučené vkládání, které představuje slova ze slovníku 87636 jako 300-dimenzionální vektor:

input = Input{87636, sparse=true}    # word sequence, as one-hot vector, sparse format
embEn = EmbeddingLayer{300} (input)  # embed word as a 300-dimensional continuous vector

Kromě sparse=truetoho by jeden měl také deklarovat vstup jako řídký v konfiguračním reader bloku. Tady je příklad čtení zhuštěného textového vstupu pomocí :CNTKTextFormatReader

reader = {
    readerType = "CNTKTextFormatReader"
    file = "en2fr.txt"
    randomize = true
    input = {
        input  = { alias = "E" ; dim = 87636 ;  format = "sparse" }
        labels = { alias = "F" ; dim = 98624 ;  format = "sparse" }
    }
}

Pokud místo toho už vložené vektory existují a měly by být načteny ze souboru, vypadalo by to takto:

input = Input{87636, sparse=true}     # word sequence, as one-hot vector, sparse format
embEn = EmbeddingLayer{300, embeddingPath="embedding-en.txt", transpose=true} (w) # embedding from disk

kde by se měl soubor "embedding-en.txt" skládat z 87 636 textových řádků, z nichž každý se skládá z 300 čísel oddělených mezerami. Vzhledem k tomu, že tento soubor ukládá vkládání jako řádky místo sloupců, transpose=true transponuje matici za běhu.

RekurentníLSTMLayer{}, RecidivujícíLSTMLayerStack{}

Funkce továrny pro vytvoření jednovrstvé nebo vícevrstvé rekurentní LSTM.

RecurrentLSTMLayer {outDim, cellShape = None,
                    goBackwards = false,
                    usePeepholes = false,
                    init = 'glorotUniform', initValueScale = 1,
                    enableSelfStabilization = false,
                    allowOptimizedEngine = false}
RecurrentLSTMLayerStack {layerDims,
                         cellShapes = None,
                         usePeepholes = false,
                         init = 'glorotUniform', initValueScale = 1,
                         enableSelfStabilization = false,
                         allowOptimizedEngine = false}

Parametry

  • outDim (RecurrentLSTMLayer{}): dimenze výstupu sítě. Chcete-li označit tensor pořadí>1, může to být vektor, např. (40:2)
  • layerDims (RecurrentLSTMLayerStack{}): pole dimenzí vnitřních vrstev sítě a výstupu
  • cellShape RecurrentLSTMLayer{}(, volitelné): rozměr buňky LSTM. Za normálních okolností je to stejné jako outDim. Pokud je zadána jiná hodnota, vloží se další lineární projekce, která bude převedena z dimenze buňky na výstup.
  • cellShapes ( (RecurrentLSTMLayerStack{}, volitelné): matice hodnot, jako cellShapeRecurrentLSTMLayer() je označení projekce
  • goBackwards (volitelné): Pokud je true, opakování se spustí zpětně.
  • usePeepholes (volitelné): Pokud je pravda, použijte připojení peephole v LSTM.
  • init ('heNormal'|'glorotUniform'|...): typ inicializace pro váhy. Úplný seznam možností inicializace najdete tady.
  • initValueScale: Inicializace náhodné odchylky se vynásobí tímto
  • enableSelfStabilization (volitelné): Pokud je pravda, vložte operaci "stabilizátoru", která se podobá StabilizerLayer{}
  • allowOptimizedEngine (volitelné, výchozí false): pokud je true, použijte modul RNN optimalizovaný pro cuDNN, pokud je to možné.

Návratová hodnota

Funkce, která implementuje požadované vrstvy, které aplikují nebo aplikují opakující se LSTM na vstupní sekvenci. Tato vrstva (zásobník) mapuje vstupní sekvenci skrytých stavů se stejnou délkou.

Description

To implementuje opakující se LSTM, které se má použít na posloupnost vstupů, ve dvou variantách: jedna vrstva a vícevrstvé zásobník. Tato operace automaticky zpracovává vstup s proměnnou délkou. Počáteční hodnota skrytého stavu a buňky je 0.

Použití této vrstvy na vstupní sekvenci vrátí sekvenci skrytých stavů opakujícího se LSTM (hodnota buňky paměti LSTM není vrácena). Vrácená sekvence má stejnou délku jako vstup. Pokud je žádoucí pouze poslední stav, například ve scénářích sekvenční klasifikace nebo některých scénářů sekvence k posloupnosti, použijte BS.Sequences.Last() k extrahování skrytého stavu poslední položky. (Při zpětném opakování byste použili BS.Sequences.First().)

Pokud chcete vytvořit obousměrný model s RecurrentLSTMLayer(), použijte dvě vrstvy, jednu s goBackwards=truea Splice() dva výstupy dohromady. RecurrentLSTMLayerStack() v současné době nepodporuje obousměrné modely, je nutné ho ručně sestavit pomocí více RecurrentLSTMLayer()/Splice() kombasů.

Použití modulu CuDNN5 RNN

Tato funkce pokud je to možné, automaticky použije optimalizovaný modul RNN pro CuDNN5, pokud je to možné.

  • zadaný model je takový, který lze implementovat funkcí CuDNN5.
    • bez projekce (bez cellShape parametru)
    • žádná připojení otvoru pro píp
    • bez samoobslužné stabilizace
    • nejdou dozadu
    • pro RecurrentLSTMLayerStack{}, všechny dimenze vrstvy mají stejnou hodnotu.
  • allowOptimizedEngine=true

Konkrétně CNTK vyžaduje povolení allowOptimizedEngine=true. Důvodem je, že cuDNN5 RNN se implementuje jako CNTK primitivní operace, která vyžaduje GPU. Mnoho skutečných systémů však používá gpu pro trénování, ale servery jen pro procesor v nasazení. CuDNN5 RNN zde není vhodný. (Pro trénování je teoreticky možné použít síť RNN5 CuDNN5 a nahradit ji pro nasazení operací úprav ekvivalentní explicitní implementací LSTM v BrainScriptu.)

Poznámky

Pokud allowOptimizedEngine=true jsou tyto dvě varianty vrstev obálkami kolem primitiv.OptimizedRNNStack()

Příklad

Jednoduchý klasifikátor textu, který spouští posloupnost slov opakováním a pak předává poslední skrytý stav LSTM do třídy softmax, může mít tento formulář:

w = Input{...}                   # word sequence (one-hot vectors)
e = EmbeddingLayer {150} (w)     # embed as a 150-dimensional dense vector
h = RecurrentLSTMLayer {300} (e) # left-to-right LSTM with hidden and cell dim 300
t = BS.Sequences.Last (h)        # extract last hidden state
z = DenseLayer {10000, activation=Softmax} (t)  # softmax classifier

Pokud chcete změnit výše uvedený příklad na 3vrstvé zásobník, který používá modul CuDNN5 RNN, změňte tento řádek:

h = RecurrentLSTMLayerStack {(300:300:300), allowOptimizedEngine=true} (e)

Pokud chcete vytvořit obousměrný jednovrstvé LSTM (například pomocí poloviny skryté dimenze ve srovnání s výše), použijte toto:

hFwd = RecurrentLSTMLayer {150} (e)
hBwd = RecurrentLSTMLayer {150, goBackwards=true} (e)
h = Splice (hFwd:hBwd)

DelayLayer{}

Funkce továrny pro vytvoření vrstvy, která zpožďuje vstup.

DelayLayer {T=1, defaultHiddenActivation=0}

Parametry

  • T: počet časových kroků, které se mají zpozdit. Pokud chcete získat přístup k budoucím hodnotám, použijte zápornou hodnotu.
  • defaultHiddenActivation: hodnota, která se má použít pro zpožděné rámce na hranicích

Návratová hodnota

Funkce, která implementuje požadovanou operaci zpoždění.

Description

Tato operace zpožďuje vstupní sekvenci podle T kroků (výchozí 1). To je užitečné například k přeměně sekvence slov na sekvenci překrývajících se slov trojitých.

Představte si vstupní sekvenci "a b c b", která se zakóduje jako sekvence vektorů 1-horkých takto:

1 0 0 0
0 1 0 1
0 0 1 0

V této části je každý sloupec jedním horkým vektorem a odpovídá slovu. Při použití DelayLayer{T=1} na tento vstup se vygeneruje tato posloupnost:

0 1 0 0
0 0 1 0
0 0 0 1

Všechny tokeny se zpozdí o jeden a první pozice se vyplní jako vektor 0. Stejně tak použití DelayLayer{T=-1} (záporné zpoždění) poskytne přístup k budoucím hodnotám a pad zprava s nulou:

0 0 0 0
1 0 1 0
0 1 0 0

Poznámky

Tato vrstva je obálka kolem PastValue() a FutureValue() primitiv.

Příklad

Následující příklad ukazuje, jak naskládat tři sousední slova do trigramového vektoru:

x  = ...                   # input value, e.g. a N-dimensional one-hot vector
xp = DelayLayer{} (x)      # previous value
xn = DelayLayer{T-1} (x)   # next value (negative delay)
tg = Splice (xp : x : xn)  # concatenate all into a 3N-dimensional three-hot vector

BatchNormalizationLayer{}, LayerNormalizationLayer, StabilizerLayer{}{}

Funkce továrny pro vytváření vrstev pro dávkové normalizaci, normalizaci vrstev a samoobslužnou stabilizaci.

BatchNormalizationLayer {spatialRank = 0,
                         normalizationTimeConstant = 5000,
                         initialScale = 1, epsilon = 0.00001, useCntkEngine = true}
LayerNormalizationLayer {initialScale = 1, initialBias = 0}
StabilizerLayer{}

Parametry

BatchNormalizationLayer:

  • spatialRank: Parametry normalizace jsou ve fondu nad prvními spatialRank dimenzemi. Aktuálně povolené hodnoty jsou 0 (bez sdružování) a 2 (sdružování napříč všemi pixelovými pozicemi obrázku)
  • normalizationTimeConstant (výchozí hodnota 5000): časová konstanta ve vzorcích filtru s nízkým průchodem prvního pořadí, který se používá k výpočtu statistik střední hodnoty/odchylky pro použití odvozování
  • initialScale: počáteční hodnota parametru škálování
  • epsilon: malá hodnota, která se při výpočtu inverzní hodnoty přičte k odhadu odchylky
  • useCntkEngine: pokud ano, použijte nativní implementaci CNTK. Pokud je false, použijte implementaci cuDNN (pouze GPU).

LayerNormalizationLayer:

  • initialScale: počáteční hodnota parametru škálování
  • initialBias: počáteční hodnota parametru předsudku

Návratová hodnota

Funkce, která implementuje vrstvu, která provádí operaci normalizace.

Description

BatchNormalizationLayer{} implementuje techniku popsanou v dávkové normalizaci: Zrychlení hlubokého síťového trénování snížením interního kovariantového posunu (Sergey Ioffe, Christian Szegedy). Normalizuje své vstupy pro každý minibatch pomocí minibatch střední/variance a de-normalizuje ho s naučeným faktorem škálování a předsudky.

Odvozování, místo použití minibatch střední/rozptyl, dávkové normalizace používá dlouhodobý průběžný průměr/var odhad. Tento odhad se vypočítá během trénování pomocí minibatchové statistiky filtrování s nízkým průchodem. Časovou konstantu filtru nízkého průchodu lze upravit parametrem normalizationTimeConstant . Doporučujeme začít s výchozím nastavením (5000), ale experimentovat s jinými hodnotami, obvykle v řádu několika tisíc až desítek tisíc.

LayerNormalizationLayer{} implementuje normalizaci vrstev (Jimmy Lei Ba, Jamie Ryan Kiros, Geoffrey E. Hinton). Normalizuje každý vstupní vzorek tak, že odečte střední hodnoty ve všech prvcích vzorku a pak vydělí směrodatnou odchylku nad všemi prvky vzorku.

StabilizerLayer{}implementuje samoobslužný stabilizátor na samo stabilizovanou hlubokou neurální síť (P. Ghahremani, J. Droppo). Tato jednoduchá, ale efektivní technika vynásobí svůj vstup učením skalární (ale na rozdíl od normalizace vrstev ne normalizuje vstup, ani neodčítá průměr). Všimněte si, že ve srovnání s původním papírem, který navrhuje lineární skalár beta nebo exponenciální Exp (beta), jsme zjistili, že je výhodné použít zaostřenou operaci softplus za druhý autor návrh, který se vyhne negativním hodnotám i nestabilitě z exponenciální.

Poznámky

BatchNormalizationLayer{} je obálka kolem primitivního BatchNormalization() . LayerNormalizationLayer{} a StabilizerLayer{} jsou vyjádřeny přímo v BrainScriptu.

Příklad

Typická vrstva v konvoluční síti s dávkovou normalizací:

MyLayer (x, depth, initValueScale) =
{
    c = ConvolutionalLayer {depth, (5:5), pad=true, initValueScale=initValueScale} (x)
    b = BatchNormalizationLayer {spatialRank = 2} (c)    #####
    r = ReLU (b)
    p = MaxPoolingLayer {(3:3), stride = (2:2)} (r)
}.p

FeatureMVNLayer{}

Funkce továrny k vytvoření vrstvy, která normalizuje vstup funkcí střední a směrodatnou odchylkou.

FeatureMVNLayer{}

Parametry

Prázdný seznam {}argumentů .

Návratová hodnota

Funkce, která implementuje vrstvu, která provádí operaci normalizace.

Description

Tato vrstva normalizuje vstup do neurální sítě jeho předsudky a odchylky. Tyto hodnoty se odhadují předem provedením úplného průchodu trénovacích dat a následným uložením a ukotvením. K tomu dojde automaticky.

Vzhledem k tomu, že parametry této vrstvy jsou před hlavním trénováním předem předpočítané, lze je použít pouze u proměnných deklarovaných jako Input{}.

Příklad

Toto je typický začátek neurální sítě pro akustické modelování řeči:

features = Input{40}      # e.g. speech features
featNorm = FeatureMVNLayer{} (features)
h = DenseLayer{2048} (featNorm)
...
  • Last updated on