Teilen über

Ebenenreferenz mit BrainScript

CNTK eine Reihe gemeinsamer "Ebenen" vordefinierter "Ebenen", wodurch es sehr einfach ist, einfache Netzwerke zu schreiben, die aus Standardebenen bestehen, die oben aufeinander geschichtet sind. Layer sind Funktionsobjekte, die wie normale BrainScript-Funktionen verwendet werden können, aber lernbare Parameter enthalten und ein zusätzliches Paar {} zum Übergeben von Konstruktionsparametern oder Attributen haben.

Dies ist beispielsweise die Netzwerkbeschreibung für ein einfaches 1-ausgeblendetes Layermodell mit der DenseLayer{} Ebene:

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

das kann dann z. B. zur Schulung gegen ein entropisches Kriterium verwendet werden:

ce = CrossEntropy (labels, p)

Wenn Ihr Netzwerk eine direkte Verketteung von Vorgängen ist (viele sind), können Sie die Alternative verwenden. Sequential() Notation:

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

und rufen sie wie folgt auf:

p = myModel (features)

Beispielmodelle

Im Folgenden wird ein Slottagger angezeigt, der eine Wortsequenz einbettet, es mit einem wiederkehrenden LSTM verarbeitet und dann jedes Wort klassifiziert:

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

Und das folgende ist ein einfaches konvolutionales Netzwerk für die Bilderkennung:

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}
)

Parameterfreigabe

Wenn Sie einer Variable eine Ebene zuweisen und sie an mehreren Stellen verwenden, werden die Parameter freigegeben. Wenn Sie sagen

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

h1 und h2teilt dieselben Parameter, wie lay() die gleiche Funktion in beiden Fällen. Im obigen Fall ist dies wahrscheinlich nicht das gewünschte, also beachten Sie. Wenn beide Aufrufe lay() von oben unterschiedliche Parameter aufweisen sollen, denken Sie daran, zwei separate Instanzen zu definieren, z lay1 = DenseLayer{...} . B. und lay2 = DenseLayer{...}.

Warum dieses Verhalten? Ebenen ermöglichen die Freigabe von Parametern in Abschnitten eines Modells. Berücksichtigen Sie ein DSSM-Modell, das zwei Eingabebilder verarbeitet, sagen doc und query identisch mit derselben Verarbeitungskette, und vergleicht die resultierenden ausgeblendeten Vektoren:

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)

wo imageToVec ist der Teil des Modells, das Bilder in flachen Vektor konvertiert. imageToVec ist ein Funktionsobjekt, das wiederum mehrere Funktionsobjekte enthält (z. B. drei Instanzen von ConvolutionalLayer{}). imageToVec wird einmal instanziiert, und diese Instanz enthält die lernbaren Parameter aller enthaltenen Funktionsobjekte. Beide Aufrufe model() teilen diese Parameter in Anwendung, und deren Farbverlauf ist die Summe der beiden Aufrufe.

Beachten Sie schließlich, dass in dem obigen Beispiel querydoc die gleichen Dimensionen enthalten sein müssen, da sie über das gleiche Funktionsobjekt verarbeitet werden, und die erste Ebene des Funktionsobjekts hat seine Eingabedimension, die auf die übereinstimmungen query zwischen beiden und doc. Wenn sich ihre Dimensionen unterscheiden, schlägt dieses Netzwerk fehl, und die Dimensioninference/Validierung schlägt mit einer Fehlermeldung fehl.

Implementierungsnotiz

Viele Ebenen sind Wrapper um zugrunde liegende CNTK Grundtypen zusammen mit den entsprechenden erforderlichen lernbaren Parametern. Umbruch des Convolution() Grundtyps. ConvolutionalLayer{} Die Vorteile der Verwendung von Ebenen sind:

  • Ebenen enthalten lernbare Parameter der richtigen Dimension
  • Ebenen sind kompposierbar (cf. Sequential())

DenseLayer, LinearLayer{}{}

Factory-Funktion zum Erstellen einer vollständig verbundenen Ebene. DenseLayer{} nimmt mit einer optionalen Nicht-Linearität an.

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

Parameter

  • outDim: Ausgabedimension dieser Ebene
  • activation (DenseLayer{} nur): Übergeben Sie hier eine Funktion, die als Aktivierungsfunktion verwendet werden soll, z. B. activation=ReLU
  • init ('heNormal'|'glorotUniform'|...): Initialisierungstyp für die Gewichtungen. Hier finden Sie eine vollständige Liste der Initialisierungsoptionen.
  • initValueScale: Die Zufällige Initialisierung wird mit dieser Multiplikation multipliziert.
  • bias: wenn falsch, schließen Sie keinen Bias-Parameter ein.

Rückgabewert

Eine Funktion, die die gewünschte voll verbundene Ebene implementiert. Siehe Beschreibung.

BESCHREIBUNG

Verwenden Sie diese Fabrikfunktionen, um eine voll verbundene Ebene zu erstellen. Verwenden DenseLayer{} Sie, wenn Sie eine Aktivierungsfunktion enthalten möchten, andernfalls LinearLayer{}.

Jede dieser Fabrikfunktionen erstellen ein Funktionsobjekt, das eine lernbare Gewichtsmatrix enthält und es sei bias=falsedenn, eine lernbare Verzerrung. Das Funktionsobjekt kann wie eine Funktion verwendet werden, die eine der folgenden Formeln implementiert:

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

wobei W es sich um eine Gewichtsmatrix der Dimension handelt, b ist die Verzerrung der [outDim x (dimension of v)][outdim]Dimension, und der resultierende Wert hat Dimension (oder Tensordimensionen) wie angegebenoutDim.

Tensor-Unterstützung

Wenn die zurückgegebene Funktion auf eine Eingabe eines Tensor-Rangs > 1 angewendet wird, z. B. ein 2D-Bild, W hat die Dimension [outDim x (first dimension of input) x (second dimension of input) x ...].

Andererseits kann es sich um einen Vektor sein, outDim der z. B. Tensordimensionen (10:10)angibt. In diesem Fall W hat die Dimension die Dimension [outDim[0] x outDim[1] x ... x (dimension of input)]und b wird die Tensordimensionen [outDim[0] x outDim[1] x ...]aufweisen.

CNTK Matrixprodukt interpretiert diese zusätzlichen Ausgabe- oder Eingabedimensionen so, als ob sie in einen langen Vektor abgeflacht wurden. Weitere Informationen hierzu finden Sie in der Dokumentation Times()

Beispiel:

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

oder alternativ:

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

ConvolutionalLayer{}

Erstellt eine Konvolutionsebene mit optionaler Nicht-Linearität.

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

Parameter

  • numOutputChannels: Anzahl der Ausgabekanäle (Anzahl der Filter)
  • filterShape: räumliches Ausmaß des Filters, z. B. (5:5) für einen 2D-Filter. Die Eingabekanaldimension ist hier nicht enthalten.
  • activation: optionale Nicht-Linearität, z. B. activation=ReLU
  • init ('heNormal'|'glorotUniform'|...): Typ der zufälligen Initialisierung für die Gewichtungen. Hier finden Sie eine vollständige Liste der Optionen für zufällige Initialisierungen.
  • initValueScale: Die Zufällige Initialisierung wird mit dieser Multiplikation multipliziert.
  • stride: Inkrement beim Gleiten des Filters über die Eingabe. Z. B. (2:2) um die Abmessungen um 2 zu verringern
  • pad: wenn nicht festgelegt (Standard), wird der Filter über den "gültigen" Eingabebereich verschoben, das heißt, es wird kein Wert außerhalb des Bereichs verwendet. Wenn pad sie andererseits festgelegt ist, wird der Filter auf alle Eingabepositionen angewendet, und Werte außerhalb des gültigen Bereichs werden als Null angesehen.
  • lowerPad, upperPad: Geben Sie explizit unterschiedliche Seitenränder für den Abstand an. Filter werden über einen gültigen Bereich verschoben, der mit Nullen (praktisch) erweitert wird. Sie fügen z. B. lowerPad=(1:2) eine Spalte von Nullen und zwei Zeilen von Nullen an. Die Dimension der Ausgabe wird entsprechend erweitert.
  • bias: wenn falsch, schließen Sie keinen Bias-Parameter ein.

Rückgabewert

Eine Funktion, die die gewünschte voll verbundene Ebene implementiert. Siehe Beschreibung.

BESCHREIBUNG

Verwenden Sie diese Fabrikfunktionen, um eine Konvolutionsebene zu erstellen.

Die resultierende Schicht wendet einen Konvolutionvorgang auf einem N-dimensionalen Tensor an. Der Aufrufer gibt die räumliche Erweiterung des Filters an. Eine Reihe von Filtern eines bestimmten räumlichen Umfangs (z. B. (5:5)) wird mit jedem Speicherort der Eingabe korreliert (z. B. ein [640 x 480]Bild mit Größe). Vorausgesetzt, dass die Abstandseinstellung aktiviert ist () und strides 1 sind, generiert dies einen Ausgabebereich derselben Dimension (pad[640 x 480]).

Normalerweise werden viele Filter gleichzeitig angewendet. numOutputChannels gibt die Zahl an, damit für jeden Eingabespeicherort ein gesamter Vektor numOutputChannels erzeugt wird. In unserem obigen Beispiel würde die Einstellung numOutputChannels auf 64 in einem [640 x 480 x 64]Größen-Tensor liegen. Diese letzte Achse wird als Kanaldimension bezeichnet.

Wenn die Versprechung auf eine Eingabe mit einer Kanaldimension angewendet wird, besteht jeder Filter auch aus Vektoren der Kanaldimension der Eingabe. Wenn Sie z. B. eine Verbinderung mit einem angegebenen räumlichen Filterumfang (5:5) auf ein [640 x 480 x 3]Farbbild anwenden, ist jeder Filter ein [5 x 5 x 3] Tensor.

Alle numOutputChannels zusammen gestapelten Filter werden als Kernel bezeichnet. In unserem Beispiel wird das Kernel-Shape sein [5 x 5 x 3 x 64].

Im Folgenden wird die Beziehung zwischen den verschiedenen Dimensionen und Formen zusammengefasst:

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  ]

die in unserem Beispiel sind:

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  ]

Auffüllen

Wenn der Abstand nicht aktiviert ist, wird der Ausgabebereich durch die Begrenzungsorte reduziert, auf die der vollständige Filterumfang nicht angewendet werden kann. Beispielsweise würde das Anwenden eines Filters auf ein (5:5)Bild ohne Abstand die äußeren 2 Zeilen und Spalten von Pixeln dazu führen, dass der Filter außerhalb der Grenzen angewendet wird. ConvolutionalLayer{} Daher werden die Abmessungen entsprechend reduziert.

Ein [640 x 480] Bild, das mit einem (5:5) Filter ohne Abstand verbunden ist, lässt einen [636 x 476]Ausgabebereich der Größe verlassen.

Fortschritte

Die stride Parameter geben die Inkrementierung von Filtern an. Stridewerte, die größer als eins sind, führen zu einem Teil-Sampling des Ausgabebereichs. Wenn Sie z. B. ein [640 x 480] Bild mit einem Schritt (2:2) filtern, wird ein [320 x 240]Bereich mit Einer Größe mit Abstand und [318 x 238] ohne Abstand angezeigt.

Notizen

Diese Ebene ist ein Wrapper um den Convolution() Grundtyp.

Der Name der Filterkernparameter, wie im Gültigkeitsprüfungsbereich des Protokolls dargestellt, endet in .W. Die Dimension wird derzeit nicht wie [ (filterShape) x (#input channels) x numOutputChannels ] oben beschrieben angezeigt, sondern [ numOutputChannels x ((Produkt über Filterform) * (#input Kanäle)) ]'.

Beispiel:

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

DeconvLayer{}

Erstellt eine Deconvolution-Ebene.

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}

Parameter

  • numOutputChannels: Anzahl der Ausgabekanäle (Anzahl der Filter)
  • filterShape: räumlicher Umfang des Filters, z. B. (5:5) für einen 2D-Filter. Die Dimension des Eingabekanals ist hier nicht enthalten.
  • numInputChannels: Anzahl der Eingabekanäle (Anzahl der Filter des Eingabevolumens)
  • bias: Wenn false, schließen Sie keinen Bias-Parameter ein.
  • activation: optionale Nicht-Linearität, z. B. activation=ReLU
  • init ('heNormal'|'glorotUniform'|...): Art der zufälligen Initialisierung für die Gewichtungen. Hier finden Sie eine vollständige Liste der Optionen für zufällige Initialisierung.
  • initValueScale: Die Zufällige Initialisierung der Varianz wird mit dieser Multiplikation multipliziert.
  • initBias: der Anfangswert für die Bias
  • stride: erhöht sich beim Gleiten des Filters über die Eingabe. z. B. (2:2) um die Abmessungen um 2 zu reduzieren
  • autoPadding: Wenn nicht festgelegt (Standard), wird der Filter über den "gültigen" Eingabebereich verschoben, also kein Wert außerhalb des Bereichs verwendet wird. Wenn autoPadding der Filter dagegen festgelegt wird, wird der Filter auf alle Eingabepositionen angewendet, und Werte außerhalb des gültigen Bereichs werden als Null betrachtet.
  • lowerPad, upperPad: Geben Sie explizit verschiedene Ränder für den Abstand für das Ausgabevolumen an, d. h. die, die für die Eingabe in der entsprechenden konvolutionalen Ebene verwendet wurden. Es ist wichtig, sie in Übereinstimmung mit der konvolutionalen Schicht festzulegen, um dieselben Tensorabmessungen zu erzielen.

Rückgabewert

Eine Funktion, die die gewünschte voll verbundene Ebene implementiert. Siehe Beschreibung.

BESCHREIBUNG

Verwenden Sie diese Factoryfunktionen, um eine Deconvolution-Ebene zu erstellen.

Die resultierende Ebene wendet einen Deconvolution-Vorgang auf einem N-dimensionalen Tensor an. Diese Ebene ist ein Wrapper um den Convolution() Grundtyp mit deconv=true.

Ein beliebter Usecase für deconvolution ist das Rekonstruieren eines Bilds (siehe hier beispiel). Wenn konvolution einen Eingabe-2D-Feldbereich verwendet und die Korrelation mit einem 2D-Filter berechnet, übernimmt Deconvolution ein Pixel und verteilt sie über einen 2D-Bereich.

Betrachten Sie ein Bild p(.,.), eine Pixelposition (x,y) und einen zentrierten [3 x 3]-Filter mit dem folgenden Inhalt (keine Feature-Map-Tiefendimension für jetzt, d. h. einen einzigen Kanal):

[ . . c
  a b .
  . . . ]

Hier sind ein b und c Gewichte des Filters , "." Entspricht einer Nullgewichtung. Convolution() berechnet das Ausgabepixel q(x, y) an der Position (x, y) als:

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

Deconvolution übernimmt Pixel q(x,y) und verteilt sie über einen Bereich um (x,y). Wenn wir denselben Filter verwendet haben, würde er die folgenden Beiträge zu der Ausgabe r(x,y) leisten:

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

Wenn wir wissen, dass dasselbe für alle x und y über die Ebene gilt, können wir dies für r(x,y) ausdrücken:

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

oder insgesamt,

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

Dies hat dieselbe Form wie die oben beschriebene Konvolution, außer dass der Filter auf beiden Achsen gespiegelt wird.

Jetzt stellen wir Featurekarten in der Mischung vor. Das ist einfach: Anstatt von der Eingabetiefe zur Ausgabetiefe zu wechseln, gehen wir die andere Richtung.

Zusammenfassung: Convolution (W, x) == Deconvolution (W', x), wo

W : [W x H x C x K]

und

W’ = W mit seinen Werten neu angeordnet als: [(W mirrored) x (H mirrored) x K x C]

D.h., was Deconvolution() implizit tut:

  • die beiden Tiefendimensionen austauschen (Transponieren)
  • die räumlichen Dimensionen (umkehren die Reihenfolge der Daten)
  • Konvolution() mit diesen

Beispiel:

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

Siehe Bild auto encoder using Deconvolution and Unpooling for a detail example and walk through.

MaxPoolingLayer, AveragePoolingLayer{}{}

Factoryfunktionen zum Erstellen einer max- oder mittelwertigen Poolingebene.

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

Parameter

  • poolShape: die Form des Bereichs zum Pool, z. B. (2:2)
  • stride: erhöht sich beim Verschieben des Pools über die Eingabe. z. B. (2:2) um die Abmessungen um 2 zu reduzieren
  • pad: wenn nicht festgelegt (Standard), wird der Pool über den "gültigen" Eingabebereich verschoben, also kein Wert außerhalb des Bereichs verwendet wird. Wenn pad der Pool dagegen festgelegt wird, wird der Pool auf alle Eingabepositionen angewendet, und Werte außerhalb des gültigen Bereichs werden als Null betrachtet. Bei durchschnittlichen Pooling enthält die Anzahl des Mittelwerts keine gepolsterten Werte.
  • lowerPad, : upperPadGeben Sie explizit verschiedene Seitenränder für den Abstand an. Filter werden über einen gültigen Bereich verschoben, der (praktisch) mit Nullen erweitert wird. Z. B. lowerPad=(1:2) fügt eine Spalte mit Nullen und zwei Zeilen nullen an. Die Dimension der Ausgabe wird entsprechend erweitert.

Rückgabewert

Eine Funktion, die die gewünschte Poolingebene implementiert. Siehe Beschreibung.

BESCHREIBUNG

Verwenden Sie diese Factoryfunktion, um einen Poolingvorgang zu erstellen. Wird verwendet MaxPoolingLayer{} , um das Maximum über die Werte im Poolbereich zu berechnen und AveragePoolingLayer{} ihren Mittelwert zu übernehmen.

Der Poolvorgang folie ein "Poolfenster" über Speicherorte eines Eingabebereichs und berechnet entweder das Maximum oder den Mittelwert der Werte in der jeweiligen Poolregion.

Dieser Vorgang ist strukturell sehr ähnlich wie die Konvolution, außer dass der Vorgang, der auf das Gleitfenster angewendet wird, eine andere Art ist.

Alle Überlegungen zu Eingabedimensionen, Abstand und Strides gelten identisch, daher finden ConvolutionalLayer{} Sie weitere Details.

Beispiel:

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

MaxUnpoolingLayer{}

Erstellt eine max-unooling-Ebene.

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

Parameter

  • poolShape: die Form des Bereichs zum Aufheben der Poolgröße ( die Größe des Ausgabebereichs ), z. B. (2:2)
  • stride: erhöht sich, wenn der Pool über die Ausgabe gleitet. z. B. (2:2) um die Abmessungen um 2 zu erhöhen
  • pad: wenn nicht festgelegt (Standard), wird der Pool über den "gültigen" Bereich der Ausgabe verschoben, also kein Wert außerhalb des Bereichs verwendet wird.
  • lowerPad, : upperPadGeben Sie explizit verschiedene Seitenränder für den Abstand an. Filter gehen davon aus, dass ein gültiger Ausgabebereich (praktisch) erweitert wird.

Rückgabewert

Eine Funktion, die die gewünschte Unpooling-Ebene implementiert. Siehe Beschreibung.

BESCHREIBUNG

Verwenden Sie diese Factoryfunktion, um einen Unpooling-Vorgang zu erstellen.

Der Unpooling-Vorgang ist die Umkehrung eines Poolvorgangs. Es erfordert zwei Eingaben: die Ausgabe der entsprechenden Poolingschicht, sagen wir p1 , und die Eingabe der entsprechenden Poolingschicht, sagen wir r1, auch. Es folie ein "umgekehrtes Poolfenster" über die Speicherorte seiner Eingabe p1, und bezieht den Wert auf diese Position des Ausgabebereichs, der den Maximalwert im entsprechenden Poolingvorgang hatte, d. h. in r1. Die zweite Eingabe r1 ist in CNTK erforderlich, um das Ziel des Unpooling-Vorgangs zu bestimmen, da CNTK keine so genannten Switchvariablen speichert (siehe hier).

Beispiel:

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

Siehe Image auto encoder using Deconvolution and Unpooling for a detail example and walk through.

Einbetten vonLayer{}

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

Parameter

  • outDim: die Dimension des gewünschten Einbettungsvektors
  • init ('heNormal'|'glorotUniform'|...): Initialisierungstyp für die Gewichtungen. Hier finden Sie eine vollständige Liste der Initialisierungsoptionen.
  • initValueScale: Die Zufällige Initialisierung wird mit dieser Multiplikation multipliziert.
  • embeddingPath: wenn angegeben, werden einbetten nicht gelernt, aber aus einer Datei geladen und während der Schulung nicht aktualisiert.
  • transpose: ermöglicht das Laden von Einbettungen, die in transponierter Form gespeichert werden.

Rückgabewert

Eine Funktion, die die einbettende Ebene implementiert. Siehe Beschreibung.

BESCHREIBUNG

"Einbetten" bezieht sich auf Wörter oder andere diskrete Elemente durch dichte fortlaufende Vektoren. In dieser Ebene wird davon ausgegangen, dass sich die Eingabe in einem heißen Formular befindet. Z. B. für eine Vokabulargröße von 10.000 wird erwartet, dass jeder Eingabevektor dimensioniert 10.000 hat und aus Nullen besteht, außer einer Position, die eine 1 enthält. Der Index dieses Speicherorts ist der Index des Worts oder Elements, das er darstellt.

In CNTK werden die entsprechenden einbettenden Vektoren als Spalten einer Matrix gespeichert. Daher wird die Zuordnung eines Eingabeworts zu seiner Einbettung als Matrixprodukt implementiert. Damit dies sehr effizient ist, ist es wichtig, dass die Eingabevektoren im sparse Format gespeichert werden.

Fun fact: Der Farbverlauf einer einbettenden Matrix hat die Form von Farbverlaufsvektoren, die nur nicht null für Wörter sind, die in einem Minibatch angezeigt werden. Da bei realistischen Vokabularen von zehn oder hundert tausend Spalten die große Mehrheit der Spalten null sein würde, CNTK implementierte Implementierungen eine bestimmte Optimierung haben, um den Farbverlauf in "Spaltensparse"-Form darzustellen.

Bekanntes Problem: Das oben erwähnte Spaltensparverlaufsformular wird derzeit nicht von unserer 1-Bit-SGD-Parallelisierungsmethode unterstützt. Verwenden Sie stattdessen die Block-Momentum-Technik .

Beispiel

Eine gelernte Einbettung, die Wörter aus einem Vokabular von 87636 als 300-dimensionalen Vektor darstellt:

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

Zusätzlich sparse=truezu , sollte man auch eine Eingabe als sparse im reader Konfigurationsblock deklarieren. Hier ist ein Beispiel für das Lesen von wenig Texteingaben mit dem CNTKTextFormatReaderFolgenden:

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

Wenn stattdessen die einbettenden Vektoren bereits vorhanden sind und aus einer Datei geladen werden sollten, sieht es wie folgt aus:

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

wobei die Datei "embedding-en.txt" voraussichtlich aus 87.636 Textzeilen besteht, die jeweils aus 300 leer getrennten Zahlen bestehen. Da diese Datei die Einbetten als Zeilen anstelle von Spalten speichert, transpose=true wird die Matrix im Fly-Format übersetzt.

RepeatLSTMLayer{}, RepeatLSTMLayerStack{}

Factory-Funktionen zum Erstellen eines einzelschichtigen oder multiebenen wiederkehrenden 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}

Parameter

  • outDim (RecurrentLSTMLayer{}): Dimension der Ausgabe des Netzwerks. Um einen Tensor von Rang>1 zu bezeichnen, kann dies ein Vektor sein, z. B. (40:2)
  • layerDims (RecurrentLSTMLayerStack{}): Array von Dimensionen der inneren Ebenen und Ausgabe des Netzwerks
  • cellShape ( (RecurrentLSTMLayer{}, optional): Die Dimension der Zelle des LSTM. Normalerweise ist dies identisch mit outDim. Wenn ein anderer Wert angegeben wird, wird eine zusätzliche lineare Projektion eingefügt, um von der Zelldimension in die Ausgabe zu konvertieren.
  • cellShapes ( (RecurrentLSTMLayerStack{}, optional): Array von Werten wie cellShape zum RecurrentLSTMLayer() Bezeichnen der Projektion
  • goBackwards (optional): Wenn true, wird die Wiederholung rückwärts ausgeführt.
  • usePeepholes (optional): wenn wahr, verwenden Sie peephole connections in the LSTM
  • init ('heNormal'|'glorotUniform'|...): Initialisierungstyp für die Gewichtungen. Hier finden Sie eine vollständige Liste der Initialisierungsoptionen.
  • initValueScale: Die Zufällige Initialisierung wird mit dieser Multiplikation multipliziert.
  • enableSelfStabilization (optional): Wenn wahr, fügen Sie einen "Stabilisierungsvorgang" wie bei "Stabilisierung" ein, ähnlich wie bei "true". StabilizerLayer{}
  • allowOptimizedEngine (optional, Standard false): wenn true, verwenden Sie dann cuDNNs optimierte RNN-Engine, wenn möglich.

Rückgabewert

Eine Funktion, die die gewünschte Ebene(n) implementiert, die einen wiederkehrenden LSTM auf seine Eingabesequenz anwendet/anwenden. Diese Ebene (-Stack) ordnet eine Eingabesequenz einer Sequenz ausgeblendeter Zustände derselben Länge zu.

BESCHREIBUNG

Dadurch wird die wiederkehrende LSTM implementiert, die auf eine Reihe von Eingaben in zwei Varianten angewendet werden soll: eine einzelne Ebene und ein Mehrschichtstapel. Dieser Vorgang behandelt automatisch die Eingabe variabler Länge. Der Anfangswert des ausgeblendeten Zustands und der Zelle sind 0.

Das Anwenden dieser Ebene auf eine Eingabesequenz gibt die Sequenz der ausgeblendeten Zustände des wiederkehrenden LSTM (top-of-stack) zurück (der Speicherzellenwert der LSTM wird nicht zurückgegeben). Die zurückgegebene Sequenz weist die gleiche Länge wie die Eingabe auf. Wenn nur der letzte Zustand gewünscht wird, z. B. in Sequenzklassifizierungsszenarien oder einige Sequenz-zu-Sequenz-Szenarien, verwenden Sie BS.Sequences.Last() nur zum Extrahieren des ausgeblendeten Zustands des letzten Elements. (In einer Rückwärtsserie würden BS.Sequences.First()Sie .)

Um ein bidirektionales Modell mit RecurrentLSTMLayer(), verwenden Sie zwei Ebenen, eine mit goBackwards=true, und Splice() die beiden Ausgabe zusammen. RecurrentLSTMLayerStack() Derzeit werden bidirektionale Modelle nicht unterstützt, sie müssen manuell mithilfe mehrerer RecurrentLSTMLayer()/Splice() Kombinationen erstellt werden.

Verwenden des CuDNN5 RNN-Moduls

Diese Funktion verwendet automatisch das optimierte RNN-Modul von CuDNN5, sofern möglich.

  • das angegebene Modell ist eine, die von der Funktion CuDNN5 implementiert werden kann
    • keine Projektion (kein cellShape Parameter)
    • keine Peep-Loch-Verbindungen
    • keine Selbststabilisierung
    • Nicht rückwärts
    • für RecurrentLSTMLayerStack{}, alle Ebenendimensionen haben den gleichen Wert
  • allowOptimizedEngine=true

Insbesondere ist CNTK erforderlich, um die Aktivierung zu ermöglichenallowOptimizedEngine=true. Dies liegt daran, dass das CuDNN5 RNN als CNTK Grundtypvorgang implementiert wird, der eine GPU erfordert. Viele reale Systeme verwenden JEDOCH GPUs für Schulungen, aber NUR CPU-Server in der Bereitstellung. Die CuDNN5 RNN ist hier nicht geeignet. (Es ist theoretisch möglich, die CuDN5 RNN5 RNN für Schulungen zu verwenden und durch einen Bearbeitungsvorgang durch eine entsprechende explizite LSTM-Implementierung in BrainScript zu ersetzen.)

Notizen

Wenn allowOptimizedEngine=true diese beiden Ebenenvarianten um den Grundtyp herum umschließen OptimizedRNNStack() .

Beispiel

Ein einfacher Textklassifizierer, der eine Wortsequenz durch eine Wiederholung ausführt und dann den letzten ausgeblendeten Zustand des LSTM an einen Softmax-Klassenifer übergibt, könnte dieses Formular haben:

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

Um das obige Beispiel in einen 3-Layer-Stapel zu ändern, der das CuDN5 RNN-Modul verwendet, ändern Sie diese Zeile:

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

Um eine bidirektionale einschichtige LSTM (z. B. die Hälfte der ausgeblendeten Dimension im Vergleich zu oben) zu erstellen, verwenden Sie folgendes:

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

DelayLayer{}

Factory-Funktion zum Erstellen einer Ebene, die die Eingabe verzögert.

DelayLayer {T=1, defaultHiddenActivation=0}

Parameter

  • T: die Anzahl der Zeitschritte, die verzögert werden sollen. Um auf zukünftige Werte zuzugreifen, verwenden Sie einen negativen Wert
  • defaultHiddenActivation: Wert, der für die verzögerten Frames an den Grenzen verwendet werden soll

Rückgabewert

Eine Funktion, die den gewünschten Verzögerungsvorgang implementiert.

BESCHREIBUNG

Dieser Vorgang verzögert eine Eingabesequenz nach T Schritten (Standard 1). Dies ist z. B. hilfreich, um eine Wortsequenz in eine Sequenz überlappender Wörter triples zu verwandeln.

Berücksichtigen Sie eine Eingabesequenz "a b", die als Sequenz von Vektoren wie folgt codiert werden soll:

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

Hier ist jede Spalte ein heißer Vektor und entspricht einem Wort. Das Anwenden DelayLayer{T=1} auf diese Eingabe generiert diese Sequenz:

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

Alle Token werden von einem verzögert, und die erste Position wird als 0 Vektor ausgefüllt. Ebenso wird die Verwendung DelayLayer{T=-1} (negative Verzögerung) den Zugriff auf die zukünftigen Werte geben und von rechts nach rechts mit einer Null einbinden:

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

Notizen

Diese Ebene ist ein Wrapper um die und FutureValue() die PastValue() Grundtypen.

Beispiel

Im Folgenden wird gezeigt, wie drei benachbarte Wörter in einen Trigramvektor gestapelt werden:

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{}{}

Factory-Funktionen zum Erstellen von Ebenen für die Batch normalisierung, Schicht normalisierung und Selbststabilisierung.

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

Parameter

BatchNormalizationLayer:

  • spatialRank: Normalisierungsparameter werden über die ersten spatialRank Dimensionen gruppiert. Derzeit zulässige Werte sind 0 (kein Pooling) und 2 (Pooling über alle Pixelpositionen eines Bilds)
  • normalizationTimeConstant (Standard 5000): Zeitkonstanten in Beispielen des ersten Niedrigpassfilters, der zum Berechnen von Mittel-/Varianzstatistiken für die Verwendung in Schlussfolgerungen verwendet wird
  • initialScale: Initialwert des Skalierungsparameters
  • epsilon: kleiner Wert, der der Varianzschätzung hinzugefügt wird, wenn die Inverse berechnet wird
  • useCntkEngine: wenn true, verwenden Sie die native Implementierung CNTK. Wenn falsch, verwenden Sie die Implementierung von CuDNN (nur GPU).

LayerNormalizationLayer:

  • initialScale: Initialwert des Skalierungsparameters
  • initialBias: Initialwert des Bias-Parameters

Rückgabewert

Eine Funktion, die eine Ebene implementiert, die den Normalisierungsvorgang ausführt.

BESCHREIBUNG

BatchNormalizationLayer{} implementiert die in der Papierbatch normalisierung beschriebene Technik : Beschleunigen der Tiefennetzwerkschulung durch Reduzieren der internen Covariate-Schicht (Sergey Ioffe, Christian Szegedy). Er normalisiert seine Eingaben für jeden Minibatch durch die Minibatch-Mittel-/Varianz und wird mit einem gelernten Skalierungsfaktor und Verzerrung normalisiert.

Anstelle der Minibatch-Mittel-/Varianz verwendet die Batch normalisierung eine langfristige Mittel-/Var-Schätzung. Diese Schätzung wird während der Schulung durch Minibatchstatistiken mit geringem Pass berechnet. Die Zeitkonstante des Low-Pass-Filters kann vom normalizationTimeConstant Parameter geändert werden. Es wird empfohlen, mit dem Standard von (5000) zu beginnen, aber experimentieren Sie mit anderen Werten, in der Regel auf der Reihenfolge von mehreren tausend bis zehn tausend.

LayerNormalizationLayer{} implementiert Layer Normalization (Jimmy Lei Ba, Jamie Ryan Kiros, Geoffrey E. Hinton). Es normalisiert jedes Eingabebeispiel, indem er den Mittelwert über alle Elemente des Beispiels subtrahiert und dann durch die Standardabweichung über alle Elemente des Beispiels geteilt wird.

StabilizerLayer{}implementiert einen Selbststabilisierungsgeber pro Self-stabilisiertes tiefen neurales Netzwerk (P. Ghahremani, J. Droppo). Diese einfache, aber effektive Technik multipliziert seine Eingabe mit einem lernbaren Skalar (aber im Gegensatz zur Layer-Normalisierung normalisiert es nicht zuerst die Eingabe, oder subtrahiert es ein Mittel). Beachten Sie, dass im Vergleich zu dem ursprünglichen Papier, das eine lineare beta Skalar oder ein exponentielles Exp (beta)Dokument vorschlägt, es nützlich ist, einen scharfen Softplus-Vorgang pro Vorschlag des zweiten Autors zu verwenden, der sowohl negative Werte als auch Instabilität aus dem Exponentiellen verhindert.

Notizen

BatchNormalizationLayer{} ist ein Wrapper um den BatchNormalization() Grundtyp. LayerNormalizationLayer{} StabilizerLayer{} und werden direkt in BrainScript ausgedrückt.

Beispiel

Eine typische Ebene in einem konvolutionalen Netzwerk mit Batch normalisierung:

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{}

Factory-Funktion, um eine Ebene zu erstellen, die Featureeingaben durch ihre Mittel- und Standardabweichung normalisiert.

FeatureMVNLayer{}

Parameter

Leere Argumentliste {}.

Rückgabewert

Eine Funktion, die eine Ebene implementiert, die den Normalisierungsvorgang ausführt.

BESCHREIBUNG

Diese Ebene normalisiert die Eingabe in ein neurales Netzwerk durch seine Verzerrung und Varianz. Diese Werte werden vor dem Voraus geschätzt, indem sie einen vollständigen Pass durch die Schulungsdaten durchführen und dann gespeichert und eingefroren werden. Dies geschieht automatisch.

Da die Parameter dieser Ebene in einem separaten Pass vor der Hauptschulung vorab komputiert werden, kann es nur auf Variablen angewendet werden, die als Input{}deklariert werden.

Beispiel

Dies ist ein typischer Anfang eines neuralen Netzwerks für die akustische Modellierung der Sprache:

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