Справочник по слоям с помощью BrainScript

CNTK предопределяет ряд общих "слоев", что упрощает запись простых сетей, состоящих из стандартных слоев, многоуровневых поверх друг друга. Слои — это объекты-функции, которые можно использовать как обычные функции BrainScript, но содержат обучаемые параметры и имеют дополнительную пару для передачи {} параметров или атрибутов конструкции.

Например, это описание сети для простой 1-скрытой модели слоя с использованием DenseLayer{} слоя:

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

которые затем могут использоваться для обучения по критерию перекрестной энтропии:

ce = CrossEntropy (labels, p)

Если сеть является прямым объединением операций (многие из них), можно использовать альтернативу. Sequential() Нотации:

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

и вызовите его следующим образом:

p = myModel (features)

Примеры моделей

Ниже показан тег слота, который внедряет последовательность слов, обрабатывает ее с помощью повторяющегося LSTM, а затем классифицирует каждое слово:

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

Ниже приведена простая сверточная сеть для распознавания изображений.

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

Общий доступ к параметрам

Если вы назначаете слой переменной и используете его в нескольких местах, параметры будут общими. Если вы говорите

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

h1 и h2 будут совместно использовать одни и те же параметры, как lay()и в обоих случаях. В приведенном выше случае это, вероятно, не то, что было нужно, поэтому помните. Если оба вызова lay() выше предназначены для разных параметров, не забудьте определить два отдельных экземпляра, например lay1 = DenseLayer{...}lay2 = DenseLayer{...}.

Так почему это поведение? Слои позволяют совместно использовать параметры в разделах модели. Рассмотрим модель DSSM, которая обрабатывает два входных изображения, скажем doc и query идентично с одной и той же цепочкой обработки, и сравнивает полученные скрытые векторы:

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)

где imageToVec является частью модели, которая преобразует изображения в плоский вектор. imageToVec — это объект функции, который, в свою очередь, содержит несколько объектов-функций (например, три экземпляра ConvolutionalLayer{}). imageToVec экземпляр создается один раз, и этот экземпляр содержит обучаемые параметры всех включенных объектов функций. Оба вызова model() будут совместно использовать эти параметры в приложении, и их градиенты будут суммой обоих вызовов.

Наконец, обратите внимание, что если в приведенном выше примере query и doc должны иметь одинаковые измерения, так как они обрабатываются через один и тот же объект функции, а первый слой объекта функции имеет его входное измерение, соответствующее обоим query и doc. Если их размеры отличаются, эта сеть неправильно сформирована, а вывод или проверка измерения завершится ошибкой.

Примечание о реализации

Многие слои — это оболочки для базовых CNTK примитива, а также соответствующие необходимые обучаемые параметры. Например, ConvolutionalLayer{} заключает в оболочку Convolution() примитив. Преимущества использования слоев:

• слои содержат обучаемые параметры правильного измерения
• слои компонуемые (cf. Sequential())

DenseLayer{}, LinearLayer{}

Функция фабрики для создания полностью подключенного слоя. DenseLayer{} принимает необязательную нелинейность.

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

Параметры

• outDim: выходное измерение этого слоя
• activation (DenseLayer{} только): передайте здесь функцию, которая будет использоваться в качестве функции активации, например activation=ReLU
• init ('heNormal'|'glorotUniform'|...): тип инициализации для весовых коэффициентов. Полный список параметров инициализации см. здесь.
• initValueScale: отклонение случайной инициализации умножается на следующее.
• bias: если значение false, не включайте параметр предвзятости.

Возвращаемое значение

Функция, реализующая требуемый полностью подключенный слой. См. описание.

Описание

Используйте эти функции фабрики для создания полностью подключенного слоя. Используйте, DenseLayer{} если требуется включить функцию активации, в противном случае LinearLayer{}.

Каждая из этих функций фабрики создает объект функции, содержащий обучаемую матрицу веса и, если bias=falseтолько это не является необученной предвзятостью. Объект функции можно использовать как функцию, которая реализует одну из следующих формул:

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

где W является матрица веса измерения [outDim x (dimension of v)], b является смещением измерения [outdim], а результирующее значение имеет измерение (или тензорные измерения), как указано outDimв .

Поддержка Tensor

Если возвращаемая функция применяется к входным данным тензорного ранга > 1, например к 2D-изображению, W будет иметь измерение [outDim x (first dimension of input) x (second dimension of input) x ...].

С другой стороны, может быть вектором, outDim который задает измерения тензора, например (10:10). В этом случае W будет иметь измерение [outDim[0] x outDim[1] x ... x (dimension of input)]и b будет иметь тензорные измерения [outDim[0] x outDim[1] x ...].

матричное произведение CNTK интерпретирует эти дополнительные выходные или входные измерения, как если бы они были сплощены в длинный вектор. Дополнительные сведения об этом см. в документации Times()

Пример:

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

или также:

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

ConvolutionalLayer{}

Создает слой свертки с необязательной нелинейностью.

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

Параметры

• numOutputChannels: число каналов вывода (количество фильтров)
• filterShape: пространственный экстент фильтра, например (5:5) для 2D-фильтра. Измерение входного канала не должно быть включено здесь.
• activation: необязательная нелинейность, например. activation=ReLU
• init ('heNormal'|'glorotUniform'|...): тип случайной инициализации для весовых коэффициентов. Полный список вариантов случайной инициализации см. здесь.
• initValueScale: отклонение случайной инициализации умножается на следующее.
• stride: увеличивается при скольжения фильтра по входным данным. (2:2) Например, чтобы уменьшить размеры на 2
• pad: если не задано (по умолчанию), фильтр будет перемещен по "допустимой" области входных данных, то есть не используется значение за пределами области. Если pad задано с другой стороны, фильтр будет применяться ко всем входным позициям, а значения за пределами допустимого региона будут считаться нулевыми.
• lowerPad, : upperPadявно укажите различные поля для заполнения. Фильтры будут перемещены по допустимому региону, который (практически) дополнен нулями. Например, lowerPad=(1:2) добавит столбец с нулями и две строки нуля. Измерение выходных данных расширяется соответствующим образом.
• bias: если значение false, не включайте параметр предвзятости.

Возвращаемое значение

Функция, реализующая требуемый полностью подключенный слой. См. описание.

Описание

Используйте эти функции фабрики для создания слоя сверток.

Полученный слой применяет операцию свертки к тензору N-измерений. Вызывающий объект задает пространственное расширение фильтра. Набор фильтров заданного пространственного экстента (например (5:5), ) сопоставляется с каждым расположением входных данных (например [640 x 480], изображением размера). Если заполнение включено (pad) и шаги имеют значение 1, это приведет к созданию выходной области одного измерения ([640 x 480]).

Как правило, одновременно применяются многие фильтры. numOutputChannels указывает число, поэтому для каждого входного расположения создается весь вектор numOutputChannels . В приведенном выше примере значение numOutputChannels 64 будет иметь размер тензора [640 x 480 x 64]. Эта последняя ось называется измерением канала.

При применении свертки к входным данным с измерением канала каждый фильтр также будет состоять из векторов измерения канала входных данных. Например, при применении свертки с заданным объемом пространственного (5:5) фильтра к [640 x 480 x 3]цвету изображения размера каждый фильтр будет тензором [5 x 5 x 3] .

Все numOutputChannels фильтры, сложенные вместе, называются ядром. В нашем примере будет фигура [5 x 5 x 3 x 64]ядра.

Ниже приведены сведения о связи между различными измерениями и фигурами:

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  ]

в нашем примере:

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  ]

Заполнение

Если заполнение не включено, выходной регион будет сокращен с помощью расположений границ, к которым нельзя применить полный экстент фильтра. Например, применение фильтра экстентов (5:5)к изображению без заполнения, внешние 2 строки и столбцы пикселей могут привести к тому, что фильтр будет применен вне границ. Следовательно, ConvolutionalLayer{} уменьшит размеры соответствующим образом.

Изображение [640 x 480] , свертываемое с фильтром (5:5) без заполнения, покинет выходной [636 x 476]регион размера.

Успехов

Параметры stride указывают приращение фильтров. Значения шага, превышающие один, приведут к вложенной выборке выходного региона. Например, фильтрация [640 x 480] изображения с помощью шага (2:2) приведет к [320 x 240]тому, что область размером с заполнением и [318 x 238] без заполнения.

Примечания

Этот слой является оболочкой вокруг Convolution() примитива.

Имя параметров ядра фильтра, как показано в разделе проверки журнала, завершится .W. Измерение в настоящее время не будет отображаться, как [ (filterShape) x (#input channels) x numOutputChannels ] описано выше, но вместо этого [ numOutputChannels x ((product over filter shape) * (#input channel)) ]'.

Пример:

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

DeconvLayer{}

Создает слой деконволюции.

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}

Параметры

• numOutputChannels: число каналов вывода (количество фильтров)
• filterShape: пространственный экстент фильтра, например (5:5) для 2D-фильтра. Измерение входного канала не должно быть включено здесь.
• numInputChannels: число входных каналов (количество фильтров входного тома)
• bias: если значение false, не включайте параметр предвзятости.
• activation: необязательная нелинейность, например. activation=ReLU
• init ('heNormal'|'glorotUniform'|...): тип случайной инициализации для весовых коэффициентов. Полный список вариантов случайной инициализации см. здесь.
• initValueScale: отклонение случайной инициализации умножается на следующее.
• initBias: начальное значение смещения
• stride: увеличивается при скольжения фильтра по входным данным. (2:2) Например, чтобы уменьшить размеры на 2
• autoPadding: если не задано (по умолчанию), фильтр будет перемещен по "допустимой" области входных данных, то есть не используется значение за пределами области. Если autoPadding задано с другой стороны, фильтр будет применяться ко всем входным позициям, а значения за пределами допустимого региона будут считаться нулевыми.
• lowerPad, : upperPadявно укажите различные поля для заполнения выходного тома, т. е. те, которые использовались для ввода в соответствующем сверточных слоях. Важно задать их в соответствии с сверточным слоем для достижения одинаковых тензорных измерений.

Возвращаемое значение

Функция, реализующая требуемый полностью подключенный слой. См. описание.

Описание

Используйте эти функции фабрики для создания слоя деконволюции.

Полученный слой применяет операцию деконволюции к тензору N-измерений. Этот слой является оболочкой вокруг Convolution() примитива с deconv=true.

Одним из популярных вариантов использования для деконволюции является воссоздание изображения (см. здесь, например). Если свертка принимает входную область 2D-восприимчивого поля и вычисляет корреляцию с 2D-фильтром, деконволюция принимает пиксель и распределяет его по 2D-области.

Рассмотрим изображение p(.,.), пиксельное расположение (x,y) и центрированную фильтр [3 x 3] со следующим содержимым (пока размер глубины карты признаков отсутствует, т. е. один канал):

[ . . c
  a b .
  . . . ]

Здесь b и c являются весами фильтра, ". Соответствует нулевому весу. Convolution() вычисляет выходной пиксель q(x, y) в расположении (x, y) как:

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

Деконволюция принимает пиксели q(x,y) и распределяет их по региону вокруг (x,y). Если бы мы использовали тот же фильтр, он внес бы следующие вклады в выходные данные 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) 

Зная, что одно и то же относится ко всем x и y в плоскости, мы можем выразить это для 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) 

или в общей сложности,

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

Это имеет ту же форму, что и сверток выше, за исключением того, что фильтр зеркально отражается по обе оси.

Теперь мы представляем карты функций в смеси. Это легко: вместо того, чтобы переходить от глубины ввода к глубине вывода, мы идем в другое направление.

Вкратце, convolution (W, x) == Deconvolution (W', x), где

W : [W x H x C x K]

и

W’ = W со своими значениями, переупорядоченными следующим образом: [(W mirrored) x (H mirrored) x K x C]

Т.е. то, что deconvolution() делает неявно:

• обмен двумя измерениями глубины (транспонирование)
• пространственные измерения (обратный порядок данных)
• Сверток() с этими параметрами

Пример:

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

Подробный пример и пошаговое руководство см. в статье об автоматическом кодировщике изображений с помощью deconvolution и unpooling .

MaxPoolingLayer{}, AveragePoolingLayer{}

Функции фабрики для создания максимального или среднего уровня пула.

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

Параметры

• poolShape: форма области в пуле, например (2:2)
• stride: увеличивается при скольжения пула по входным данным. (2:2) Например, чтобы уменьшить размеры на 2
• pad: если значение не задано (по умолчанию), пул будет перемещен на "допустимую" область входных данных, то есть значение за пределами области не используется. Если pad задано с другой стороны, пул будет применяться ко всем входным позициям, а значения за пределами допустимого региона будут считаться нулевыми. Для среднего пула счетчик для среднего не включает заполненные значения.
• lowerPad, : upperPadявно укажите различные поля для заполнения. Фильтры будут перемещены по допустимому региону, который (практически) дополнен нулями. Например, lowerPad=(1:2) добавит столбец с нулями и две строки нуля. Измерение выходных данных расширяется соответствующим образом.

Возвращаемое значение

Функция, реализующая требуемый уровень пула. См. описание.

Описание

Эта функция фабрики используется для создания операции объединения в пул. Используется MaxPoolingLayer{} для вычисления максимального значения в области пула и AveragePoolingLayer{} для получения среднего значения.

Операция объединения пула слайдирует "окно пула" по расположениям входной области и вычисляет либо максимальное, либо среднее значение значений в соответствующем регионе пула.

Эта операция очень похожа на свертку, за исключением того, что операция, применяемая к скользящему окну, имеет другой характер.

Все рекомендации по измерениям ввода, заполнению и шагам применяются одинаково, поэтому см ConvolutionalLayer{} . дополнительные сведения.

Пример:

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

MaxUnpoolingLayer{}

Создает слой max-unooling.

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

Параметры

• poolShape: форма области для отмены (размер выходной области), например. (2:2)
• stride: увеличивается при скольжения пула по выходным данным. (2:2) Например, чтобы увеличить размеры на 2
• pad: если значение не задано (по умолчанию), пул будет перемещен на "допустимую" область выходных данных, то есть значение за пределами области не используется.
• lowerPad, : upperPadявно укажите различные поля для заполнения. Фильтры предполагают, что допустимый выходной регион (практически) дополнен.

Возвращаемое значение

Функция, реализующая требуемый уровень непулирования. См. описание.

Описание

Используйте эту функцию фабрики для создания операции отмены пула.

Операция отмены пула является обратной операцией пула. Для него требуются два входных данных: выходные данные соответствующего слоя пула, скажем p1 , и входные данные соответствующего уровня пула, скажем r1, тоже. Он слайдирует "обратное окно пула" по расположениям входных данных p1и проецирует значение в эту позицию области вывода, которая имела максимальное значение в соответствующей операции пула, т. е. в r1. Второй вход r1 требуется в CNTK для определения целевого объекта операции отмены пула, так как CNTK не хранит так называемые переменные switch (дополнительные сведения см. здесь).

Пример:

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

Подробный пример и пошаговое руководство см. в разделе автокодировщика изображений с помощью deconvolution и unpooling .

EmbeddingLayer{}

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

Параметры

• outDim: измерение требуемого вектора внедрения.
• init ('heNormal'|'glorotUniform'|...): тип инициализации весовых коэффициентов. Полный список параметров инициализации см. здесь.
• initValueScale: отклонение случайной инициализации умножается на следующее.
• embeddingPath: если задано, внедрение не обучается, но загружается из файла и не обновляется дополнительно во время обучения.
• transpose: позволяет загружать внедрения, хранящиеся в транспонированных формах.

Возвращаемое значение

Функция, реализующая уровень внедрения. См. описание.

Описание

"Внедрение" относится к представлению слов или других дискретных элементов плотными непрерывными векторами. В этом слое предполагается, что входные данные используются в одной горячей форме. Например, для словарного запаса размером 10 000 каждый входной вектор должен иметь размер 10 000 и состоять из нуля, за исключением одной позиции, содержащей 1. Индекс этого расположения — это индекс слова или элемента, который он представляет.

В CNTK соответствующие векторы внедрения хранятся в виде столбцов матрицы. Таким образом, сопоставление входного слова с внедрением реализуется в виде матричного продукта. Чтобы это было очень эффективным, важно, чтобы входные векторы хранились в разреженном формате.

Интересный факт: градиент матрицы внедрения имеет форму векторов градиента, которые не равны нулю для слов, наблюдаемых в мини-бэтче. Поскольку для реалистичных словарей десятков или сотен тысяч подавляющее большинство столбцов будет равно нулю, CNTK реализует конкретную оптимизацию для представления градиента в форме "разреженных столбцов".

Известная проблема: вышеприведенная форма градиента разреженного столбца в настоящее время не поддерживается нашим 1-разрядным методом параллелизации ГРАДиентОВ. Вместо этого используйте метод блочного импульса .

Пример

Выученное внедрение, представляющее слова из словаря 87636 в виде 300-мерного вектора:

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

Кроме того sparse=true, следует также объявить входные данные как разреженные в блоке конфигурации reader . Ниже приведен пример чтения разреженных текстовых входных данных с помощью CNTKTextFormatReader:

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

Если вместо этого векторы внедрения уже существуют и должны быть загружены из файла, он будет выглядеть следующим образом:

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

где файл "embedding-en.txt" должен состоять из 87 636 текстовых строк, каждая из которых состоит из 300 чисел, разделенных пробелами. Так как этот файл сохраняет внедрение в виде строк, а не столбцов, transpose=true будет транспонировать матрицу на лету.

RecurrentLSTMLayer{}, RecurrentLSTMLayerStack{}

Фабричные функции для создания одноуровневого или многоуровневого повторяющегося 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}

Параметры

• outDim (RecurrentLSTMLayer{}): измерение выходных данных сети. Чтобы обозначить тензор ранга>1, это может быть вектор, например. (40:2)
• layerDims (RecurrentLSTMLayerStack{}): массив измерений внутренних слоев и выходных данных сети.
• cellShape ((RecurrentLSTMLayer{}, необязательно): измерение ячейки LSTM. Как правило, это идентично outDim. Если задано другое значение, будет вставлена дополнительная линейная проекция для преобразования из измерения ячейки в выходные данные.
• cellShapes ((RecurrentLSTMLayerStack{}, необязательно): массив значений, например cellShape для RecurrentLSTMLayer() обозначения проекции
• goBackwards (необязательно): если значение равно true, повторение выполняется назад.
• usePeepholes (необязательно): если значение true, то используйте пипбоины соединения в LSTM.
• init ('heNormal'|'glorotUniform'|...): тип инициализации весовых коэффициентов. Полный список параметров инициализации см. здесь.
• initValueScale: отклонение случайной инициализации умножается на следующее.
• enableSelfStabilization (необязательно): если значение равно true, вставьте операцию "стабилизатора", аналогичную StabilizerLayer{}
• allowOptimizedEngine (необязательно, значение по умолчанию false): если значение равно true, используйте оптимизированный для cuDNN механизм RNN, если это возможно

Возвращаемое значение

Функция, реализующая требуемые слои, которые применяют или применяют повторяющийся LSTM к входной последовательности. Этот слой (стек) сопоставляет входную последовательность с последовательностью скрытых состояний той же длины.

Описание

Это реализует повторяющийся LSTM для применения к последовательности входных данных в двух вариантах: один слой и многоуровневый стек. Эта операция автоматически обрабатывает входные данные переменной длины. Начальное значение скрытого состояния и ячейки равно 0.

При применении этого слоя к входной последовательности возвращается последовательность скрытых состояний повторяющихся LSTM (значение ячейки памяти LSTM не возвращается). Возвращаемая последовательность имеет ту же длину, что и входные данные. Если требуется только последнее состояние, как в сценариях классификации последовательностей или некоторых сценариев последовательности, используйте для BS.Sequences.Last() извлечения только скрытого состояния последнего элемента. (В обратном повторении используется BS.Sequences.First().)

Чтобы создать двунаправленную модель с RecurrentLSTMLayer(), используйте два слоя, один с goBackwards=trueи Splice() двумя выходными данными вместе. RecurrentLSTMLayerStack() В настоящее время не поддерживает двунаправленные модели, его необходимо создать вручную с помощью нескольких RecurrentLSTMLayer()/Splice() со списком.

Использование подсистемы RNN CuDNN5

Эта функция автоматически будет использовать оптимизированный для CuDNN5 механизм RNN, если это возможно, то есть, если

• указанная модель — это модель, которая может быть реализована функцией CuDNN5.
  • без проекции (без cellShape параметра)
  • нет пип-отверстие соединений
  • без самоуспокоения
  • не идти назад
  • для RecurrentLSTMLayerStack{}всех измерений слоя одинаковое значение
• allowOptimizedEngine=true

В частности, CNTK требуется включитьallowOptimizedEngine=true. Это связано с тем, что RNN CuDNN5 реализуется как CNTK примитивная операция, требующая GPU. Однако во многих реальных системах для обучения используются GPU, но серверы только ЦП в развертывании. CuDNN5 RNN не подходит здесь. (Теоретически можно использовать CuDNN5 RNN для обучения и заменить его для развертывания операцией редактирования эквивалентной явной реализацией LSTM в BrainScript.)

Примечания

Если allowOptimizedEngine=true эти два варианта слоя являются оболочками вокруг OptimizedRNNStack() примитива.

Пример

Простой классификатор текста, который выполняет последовательность слов через повторение, а затем передает последнее скрытое состояние LSTM в классификатор softmax, может иметь следующую форму:

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

Чтобы изменить приведенный выше пример на 3-слойный стек, использующий подсистему CuDNN5 RNN, измените следующую строку:

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

Чтобы создать двунаправленный одноуровневый LSTM (например, используя половину скрытого измерения по сравнению с выше), используйте следующую команду:

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

DelayLayer{}

Фабричные функции для создания слоя, который задерживает входные данные.

DelayLayer {T=1, defaultHiddenActivation=0}

Параметры

• T: количество шагов времени для задержки. Чтобы получить доступ к будущим значениям, используйте отрицательное значение
• defaultHiddenActivation: значение, используемое для отложенных кадров на границах.

Возвращаемое значение

Функция, реализующая требуемую операцию задержки.

Описание

Эта операция задерживает входную последовательность по шагам T (по умолчанию 1). Это полезно, например, чтобы превратить последовательность слов в последовательность перекрывающихся тройных слов.

Рассмотрим входную последовательность "a b c b b", которая должна быть закодирована в виде последовательности одно горячих векторов следующим образом:

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

Здесь каждый столбец является одним горячим вектором и соответствует слову. Применение DelayLayer{T=1} к этому входу приведет к созданию следующей последовательности:

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

Все маркеры задерживаются на одну, а первая позиция заполняется в виде вектора 0. Аналогичным образом использование DelayLayer{T=-1} (отрицательная задержка) даст доступ к будущим значениям и отступ справа от нуля:

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

Примечания

Этот слой является оболочкой вокруг PastValue() и FutureValue() примитивов.

Пример

Ниже показано, как сложить три соседних слова в вектор триграммы:

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

Функции фабрики для создания слоев для пакетной нормализации, нормализации слоев и самоуспокоения.

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

Параметры

BatchNormalizationLayer:

• spatialRank: параметры нормализации объединяются в пул по первым spatialRank измерениям. В настоящее время допустимые значения: 0 (без пула) и 2 (объединение по всем позициям пикселей изображения)
• normalizationTimeConstant (по умолчанию 5000): константа времени в примерах фильтра низкого уровня первого порядка, который используется для вычисления статистики среднего и дисперсии для использования вывода
• initialScale: начальное значение параметра масштабирования
• epsilon: небольшое значение, добавляемое к оценке дисперсии при вычислении обратного значения.
• useCntkEngine: если значение true, используйте собственную реализацию CNTK. Если значение равно false, используйте реализацию cuDNN (только GPU).

LayerNormalizationLayer:

• initialScale: начальное значение параметра масштабирования
• initialBias: начальное значение параметра предвзятости

Возвращаемое значение

Функция, реализующая слой, выполняющий операцию нормализации.

Описание

BatchNormalizationLayer{}реализует метод, описанный в документе пакетной нормализации: ускорение глубокой сетевой подготовки путем сокращения внутреннего ковариатного смены (Сергей Иоффе, Кристиан Сегеди). Он нормализует входные данные для каждого мини-батча с помощью среднего или дисперсии мини-батча и отменяет его с помощью изученного коэффициента масштабирования и смещения.

В выводе вместо использования среднего или дисперсии минибатча пакетная нормализация использует долгосрочную оценку среднего/var. Эта оценка вычисляется во время обучения путем низкой фильтрации мини-баттч статистики. Константа времени фильтра с низким проходом может быть изменена normalizationTimeConstant параметром. Рекомендуется начать с значения по умолчанию (5000), но экспериментировать с другими значениями, как правило, в порядке от нескольких тысяч до десятков тысяч.

LayerNormalizationLayer{} реализует нормализацию слоев (Джимми Лей Ба, Джейми Райан Кирос, Джеффри Э. Хинтон)). Он нормализует каждый входной образец путем вычитания среднего значения во всех элементах образца, а затем деления на стандартное отклонение по всем элементам выборки.

StabilizerLayer{} реализует самостабилизатор на самостабилизируемую глубокую нейронную сеть (P. Ghahremani, J. Droppo). Этот простой, но эффективный метод умножает входные данные с обучаемым скаляром (но в отличие от нормализации слоев, он не сначала нормализует входные данные, а также не вычитает среднее значение). Обратите внимание, что по сравнению с исходным документом, который предлагает линейный скаляр beta или экспоненциальный, Exp (beta)мы обнаружили, что полезно использовать резкое действие softplus в секунду предложения автора, что позволяет избежать как отрицательных значений, так и нестабильности от экспоненциальной.

Примечания

BatchNormalizationLayer{} — это оболочка вокруг BatchNormalization() примитива. LayerNormalizationLayer{} и StabilizerLayer{} выражаются непосредственно в BrainScript.

Пример

Типичный слой в свертальной сети с пакетной нормализацией:

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

Функция фабрики для создания слоя, который нормализует входные данные признаков по их среднему и стандартному отклонению.

FeatureMVNLayer{}

Параметры

Пустой список {}аргументов.

Возвращаемое значение

Функция, реализующая слой, выполняющий операцию нормализации.

Описание

Этот слой нормализует входные данные в нейронную сеть по его предвзятости и дисперсии. Эти значения оцениваются заранее, выполняя полный проход по обучающим данным, а затем сохраненные и замороженные. Это произойдет автоматически.

Так как параметры этого слоя предварительно вычисляются в отдельном проходе перед основным обучением, его можно применять только к переменным, объявленным как Input{}.

Пример

Это типичное начало нейронной сети для акустического моделирования речи:

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