BrainScript를 사용하는 레이어 참조

  • 아티클

CNTK 여러 일반적인 "계층"을 미리 정의하므로 서로 위에 계층화된 표준 계층으로 구성된 간단한 네트워크를 매우 쉽게 작성할 수 있습니다. 레이어는 일반 BrainScript 함수처럼 사용할 수 있지만 학습 가능한 매개 변수를 보유하며 생성 매개 변수 또는 특성을 전달하는 추가 쌍이 {} 있는 함수 개체입니다.

예를 들어 계층을 사용하는 DenseLayer{} 간단한 1개의 숨겨진 계층 모델에 대한 네트워크 설명입니다.

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{...}다음과 같습니다.

그렇다면 왜 이 동작이 있을까요? 레이어를 사용하면 모델의 여러 섹션에서 매개 변수를 공유할 수 있습니다. 동일한 처리 체인과 동일하게 두 개의 입력 이미지를 doc 처리하고 query 결과 숨겨진 벡터를 비교하는 DSSM 모델을 고려합니다.

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 는 여러 함수 개체(예: 3개의 인스턴스)를 포함하는 함수 개체입니다 ConvolutionalLayer{}. imageToVec 는 한 번 인스턴스화되고 이 인스턴스는 포함된 모든 함수 개체의 학습 가능한 매개 변수를 보유합니다. 두 호출 model() 모두 애플리케이션에서 이러한 매개 변수를 공유하고 해당 그라데이션은 두 호출의 합계가 됩니다.

마지막으로 위의 예제 querydoc 에서 동일한 차원을 가져야 하는 경우 동일한 함수 개체를 통해 처리되고 해당 함수 개체의 첫 번째 계층에는 입력 차원이 둘 다 querydoc와 일치하도록 유추됩니다. 차원이 다른 경우 이 네트워크는 형식이 잘못되었으며 차원 유추/유효성 검사가 오류 메시지와 함께 실패합니다.

구현 참고 사항

많은 계층은 기본 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이면 바이어스 매개 변수를 포함하지 마세요.

반환 값

원하는 완전히 연결된 계층을 구현하는 함수입니다. 설명을 참조하세요.

Description

이러한 팩터리 함수를 사용하여 완전히 연결된 계층을 만듭니다. 활성화 함수를 포함하려는 경우, 그렇지 않으면 LinearLayer{}사용합니다DenseLayer{}.

이러한 각 팩터리 함수는 학습 가능한 가중치 행렬과 학습 가능한 바이어스가 없는 한 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 필터가 모든 입력 위치에 적용되고 유효한 지역 외부의 값은 0으로 간주됩니다.
  • lowerPad, upperPad: 안쪽 여백에 대해 다른 여백을 명시적으로 지정합니다. 필터는 (사실상) 0으로 보강된 유효한 지역에 대해 이동됩니다. 예를 들어 lowerPad=(1:2) 0의 열과 0의 두 행을 추가합니다. 출력의 차원이 그에 따라 확장됩니다.
  • bias: false이면 바이어스 매개 변수를 포함하지 마세요.

반환 값

원하는 완전히 연결된 계층을 구현하는 함수입니다. 설명을 참조하세요.

Description

이러한 팩터리 함수를 사용하여 나선형 계층을 만듭니다.

결과 계층은 N차원 텐서에 나선형 연산을 적용합니다. 호출자는 필터의 공간 확장을 지정합니다. 지정된 공간 익스텐트의 필터 집합(예: (5:5))은 입력의 모든 위치(예: [640 x 480]-크기 이미지)와 상관 관계가 있습니다. 안쪽 여백이 활성화되고 보pad폭이 1이라고 가정하면 동일한 차원()의 출력 영역이[640 x 480] 생성됩니다.

일반적으로 많은 필터가 동시에 적용됩니다. numOutputChannels 는 숫자를 지정하므로 모든 입력 위치에 대해 전체 벡터가 numOutputChannels 생성됩니다. 위의 예제에서 64로 설정 numOutputChannels 하면 크기가 큰 텐서가 [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  ]

안쪽 여백

안쪽 여백을 사용하도록 설정하지 않으면 전체 필터 익스텐트 적용할 수 없는 경계 위치에 의해 출력 영역이 줄어듭니다. 예를 들어 안쪽 여백 없이 이미지에 -extent 필터를 (5:5)적용하면 가장 바깥쪽 2개의 행과 픽셀 열이 필터가 범위를 벗어나 적용됩니다. 따라서 그에 ConvolutionalLayer{} 따라 차원을 줄입니다.

[640 x 480] 안쪽 여백이 없는 필터로 (5:5) 연결된 이미지는 크기가 큰 출력 영역을 남깁니다[636 x 476].

진보

매개 변수는 stride 필터의 증분을 지정합니다. 1보다 큰 보폭 값은 출력 영역의 하위 샘플링으로 이어져 있습니다. 예를 들어 보폭이 [640 x 480] 있는 이미지를 필터링하면 안쪽 여백이 있고 [318 x 238] 패딩이 없는 크기의 영역이 생성됩니다[320 x 240].(2:2)

참고

이 계층은 기본 형식을 Convolution() 둘러싼 래퍼입니다.

로그의 유효성 검사 섹션에 표시된 대로 필터 커널 매개 변수의 이름은 다음으로 .W끝납니다. 차원은 현재 위에서 설명한 대로 [ (filterShape) x (#input channels) x numOutputChannels ] 표시되지 않고 대신 [ numOutputChannels x ((필터 셰이프를 통해 제품) * (#input 채널)) ]'.

예제:

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 필터가 모든 입력 위치에 적용되고 유효한 지역 외부의 값은 0으로 간주됩니다.
  • lowerPad, upperPad: 출력 볼륨의 안쪽 여백에 대해 다른 여백을 명시적으로 지정합니다. 즉, 해당 나선형 계층의 입력에 사용된 여백입니다. 동일한 텐서 차원을 달성하기 위해 나선형 계층과 대응하여 설정하는 것이 중요합니다.

반환 값

원하는 완전히 연결된 계층을 구현하는 함수입니다. 설명을 참조하세요.

Description

이러한 팩터리 함수를 사용하여 분해 계층을 만듭니다.

결과 계층은 N차원 텐서에 분해 연산을 적용합니다. 이 계층은 기본 형식을 묶은 Convolution() 래퍼입니다 deconv=true.

분해에 널리 사용되는 용도 중 하나는 이미지를 재구성하는 것입니다(예: 여기 참조). 컨볼루션이 입력 2D 수용 필드 영역을 사용하고 2D 필터와의 상관 관계를 계산하는 경우 분해는 픽셀을 가져와서 2D 영역에 분산합니다.

다음 콘텐츠가 포함된 이미지 p(.,.), 픽셀 위치(x,y) 및 가운데 맞춤 [3 x 3] 필터를 고려합니다(현재는 기능 맵 깊이 차원 없음, 즉 하나의 채널).

[ . . c
  a b .
  . . . ]

여기서 b와 c는 필터 '.'의 가중치입니다. 0 가중치에 해당합니다. Convolution()은 위치(x, y)에서 출력 픽셀 q(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)

필터가 두 축을 따라 미러링된다는 점을 제외하고 위의 컨볼루션과 같은 형식입니다.

이제 기능 맵을 조합에 도입했습니다. 즉, 입력 깊이에서 출력 깊이로 이동하는 대신 다른 방향으로 이동합니다.

요약하자면, 컨볼루션(W, x) == 디컨볼루션(W', x), 여기서

W : [W x H x C x K]

그리고

W’ = W 값이 다음과 같이 다시 정렬됩니다. [(W mirrored) x (H mirrored) x K x C]

즉, Deconvolution()이 암시적으로 수행하는 것은 다음과 같습니다.

  • 2개 깊이 차원 교환(트랜스포즈)
  • 공간 차원(데이터 순서 역방향)
  • Convolution()

예제:

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

자세한 예제 및 연습은 디컨볼루션 및 풀링을 사용하는 이미지 자동 인코더 를 참조하세요.

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 풀이 모든 입력 위치에 적용되고 유효한 지역 외부의 값은 0으로 간주됩니다. 평균 풀링의 경우 평균 개수에는 패딩된 값이 포함되지 않습니다.
  • lowerPad, upperPad: 안쪽 여백에 대해 다른 여백을 명시적으로 지정합니다. 필터는 (사실상) 0으로 보강된 유효한 지역에 대해 이동됩니다. 예를 들어 lowerPad=(1:2) 0의 열과 0의 두 행이 추가됩니다. 출력의 차원이 그에 따라 확장됩니다.

반환 값

원하는 풀링 계층을 구현하는 함수입니다. 설명을 참조하세요.

Description

이 팩터리 함수를 사용하여 풀링 작업을 만듭니다. 풀 영역의 값에 대한 최대값을 계산하고 AveragePoolingLayer{} 평균을 계산하는 데 사용합니다MaxPoolingLayer{}.

풀링 작업은 입력 영역의 위치에 "풀 창"을 밀고 각 풀 지역의 최대값 또는 평균을 계산합니다.

이 작업은 구조적으로 슬라이딩 윈도우에 적용되는 연산이 다른 특성이라는 점을 제외하고는 나선형과 매우 유사합니다.

입력 차원, 안쪽 여백 및 보폭에 대한 모든 고려 사항은 동일하게 적용되므로 자세한 내용은 참조 ConvolutionalLayer{} 하세요.

예제:

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

MaxUnpoolingLayer{}

최대 침을 흘리지 않는 계층을 만듭니다.

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

매개 변수

  • poolShape: 풀을 언풀할 영역의 모양( 출력 지역 크기)(예: (2:2)
  • stride: 출력을 통해 풀을 슬라이딩할 때 증가합니다. 예를 들어 (2:2) 차원을 2씩 늘리기
  • pad: 설정되지 않은 경우(기본값) 풀이 출력의 "유효한" 영역 위로 이동됩니다. 즉, 영역 외부의 값이 사용되지 않습니다.
  • lowerPad, upperPad: 안쪽 여백에 대해 다른 여백을 명시적으로 지정합니다. 필터는 (사실상) 보강된 유효한 출력 지역을 가정합니다.

반환 값

원하는 풀링 계층을 구현하는 함수입니다. 설명을 참조하세요.

Description

이 팩터리 함수를 사용하여 풀링 해제 작업을 만듭니다.

풀링 해제 작업은 풀링 작업의 역입니다. 두 개의 입력이 필요합니다. 즉, p1 해당 풀링 계층의 출력과 해당 풀링 계층의 입력도 필요합니다 r1. 입력 위치 p1위로 "역 풀 창"을 밀고 해당 풀링 작업에서 최대값을 가진 출력 영역의 해당 위치(예: ) r1에 값을 투영합니다. CNTK 소위 스위치 변수를 저장하지 않으므로 CNTK 두 번째 입력 r1 은 풀링 해제 작업의 대상을 결정하는 데 필요합니다(자세한 내용은 여기 참조).

예제:

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

자세한 예제 및 연습은 디컨볼루션 및 풀링을 사용하는 이미지 자동 인코더 를 참조하세요.

EmbeddingLayer{}

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

매개 변수

  • outDim: 원하는 포함 벡터의 차원
  • init ('heNormal'|'glorotUniform'|...): 가중치의 초기화 유형입니다. 초기화 옵션의 전체 목록은 여기를 참조하세요.
  • initValueScale: 분산 임의 초기화에 이 값을 곱합니다.
  • embeddingPath: 지정된 경우 포함은 학습되지 않지만 파일에서 로드되며 학습 중에 더 이상 업데이트되지 않습니다.
  • transpose: 변환된 형식으로 저장된 포함을 로드할 수 있습니다.

반환 값

포함 계층을 구현하는 함수입니다. 설명을 참조하세요.

Description

"포함"은 조밀한 연속 벡터로 단어 또는 기타 불연속 항목을 나타내는 것을 나타냅니다. 이 계층은 입력이 원 핫 형식이라고 가정합니다. 예를 들어 어휘 크기가 10,000인 경우 각 입력 벡터는 차원이 10,000이고 1이 포함된 한 위치를 제외하고 0으로 구성됩니다. 해당 위치의 인덱스는 나타내는 단어 또는 항목의 인덱스입니다.

CNTK 해당 포함 벡터는 행렬의 열로 저장됩니다. 따라서 입력 단어를 포함에 매핑하는 것은 행렬 제품으로 구현됩니다. 매우 효율적이려면 입력 벡터를 스파스 형식으로 저장하는 것이 중요합니다.

재미있는 사실: 포함 매트릭스의 그라데이션은 미니배치에서 볼 수 있는 단어에 대해 0이 아닌 그라데이션 벡터 형식을 가집니다. 수십 또는 수십만 개의 실제 어휘의 경우 대부분의 열은 0이 되므로 CNTK 구현에는 "열 스파스" 형식의 그라데이션을 나타내는 특정 최적화가 있습니다.

알려진 문제: 위에서 언급한 열 스파스 그라데이션 형식은 현재 1비트 SGD 병렬화 기술에서 지원되지 않습니다. 대신 블록 모멘텀 기술을 사용하세요.

예제

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" 은 각각 300개의 공백으로 구분된 숫자로 구성된 87,636개의 텍스트 행으로 구성됩니다. 이 파일은 포함을 열 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 셀의 차원입니다. 일반적으로 이 값은 .0과 outDim동일합니다. 다른 값을 지정하면 셀 차원에서 출력으로 변환하기 위해 추가 선형 프로젝션이 삽입됩니다.
  • cellShapes(,RecurrentLSTMLayerStack{} 선택 사항): 프로젝션을 RecurrentLSTMLayer() 나타내는 것과 같은 cellShape 값 배열
  • goBackwards (선택 사항): true이면 되풀이가 뒤로 실행됩니다.
  • usePeepholes (선택 사항): true이면 LSTM에서 엿보기 연결을 사용합니다.
  • init ('heNormal'|'glorotUniform'|...): 가중치의 초기화 유형입니다. 초기화 옵션의 전체 목록은 여기를 참조하세요.
  • initValueScale: 분산 임의 초기화에 이 값을 곱합니다.
  • enableSelfStabilization (선택 사항): true이면 다음과 유사한 "안정기" 작업을 삽입합니다. StabilizerLayer{}
  • allowOptimizedEngine (선택 사항, 기본값 false): true이면 가능한 경우 cuDNN의 최적화된 RNN 엔진을 사용합니다.

반환 값

입력 시퀀스에 되풀이 LSTM을 적용/적용하는 원하는 계층을 구현하는 함수입니다. 이 계층(-스택)은 입력 시퀀스를 동일한 길이의 숨겨진 상태 시퀀스에 매핑합니다.

Description

이렇게 하면 입력 시퀀스에 적용할 되풀이 LSTM을 단일 계층과 다중 계층 스택의 두 가지 변형으로 구현합니다. 이 작업은 가변 길이 입력을 자동으로 처리합니다. 숨겨진 상태와 셀의 초기 값은 0입니다.

이 계층을 입력 시퀀스에 적용하면 (최상위 스택) 되풀이 LSTM의 숨겨진 상태 시퀀스가 반환됩니다(LSTM의 메모리 셀 값이 반환되지 않음). 반환된 시퀀스의 길이는 입력과 같습니다. 시퀀스 분류 또는 일부 시퀀스 간 시나리오와 같이 마지막 상태만 필요한 경우 마지막 항목의 숨겨진 상태만 추출하는 데 사용합니다 BS.Sequences.Last() . (이전 되풀이 BS.Sequences.First()에서는 .)

양방향 모델을 RecurrentLSTMLayer()만들려면 두 개의 레이어를 사용하고, 하나는 함께 goBackwards=true출력하고 Splice() , 두 개의 출력은 함께 사용합니다. RecurrentLSTMLayerStack() 현재 양방향 모델을 지원하지 않습니다. 여러 RecurrentLSTMLayer()/Splice() 콤보를 사용하여 수동으로 구성해야 합니다.

CuDNN5 RNN 엔진 사용

이 함수는 가능하면 CuDNN5의 최적화된 RNN 엔진을 자동으로 사용합니다.

  • 지정된 모델은 CuDNN5의 함수에서 구현할 수 있는 모델입니다.
    • 프로젝션 없음(매개 변수 없음 cellShape )
    • 엿보기 연결 없음
    • 자체 안정화 없음
    • 뒤로 가지 않음
    • 에 대해 RecurrentLSTMLayerStack{}모든 레이어 차원의 값이 같습니다.
  • allowOptimizedEngine=true

특히 CNTK 사용하도록 설정allowOptimizedEngine=true해야 합니다. 이는 CuDNN5 RNN이 GPU가 필요한 CNTK 기본 작업으로 구현되기 때문입니다. 그러나 많은 실제 시스템은 학습에 GPU를 사용하지만 배포의 CPU 전용 서버는 사용합니다. CuDNN5 RNN은 여기에 적합하지 않습니다. (이론적으로 CuDNN5 RNN을 학습에 사용하고, 배포를 위해 BrainScript에서 동등한 명시적 LSTM 구현으로 편집 작업 으로 대체할 수 있습니다.)

참고

이 경우 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

위의 예제를 CuDNN5 RNN 엔진을 사용하는 3층 스택으로 변경하려면 다음 줄을 변경합니다.

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

양방향 1층 LSTM(예: 위에 비해 숨겨진 차원의 절반을 사용)을 만들려면 다음을 사용합니다.

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

DelayLayer{}

팩터리 함수는 입력을 지연시키는 레이어를 만듭니다.

DelayLayer {T=1, defaultHiddenActivation=0}

매개 변수

  • T: 지연할 시간 단계 수입니다. 이후 값에 액세스하려면 음수 값을 사용합니다.
  • defaultHiddenActivation: 경계에서 지연된 프레임에 사용할 값입니다.

반환 값

원하는 지연 작업을 구현하는 함수입니다.

Description

이 작업은 입력 시퀀스를 단계별로 T 지연합니다(기본값 1). 예를 들어 단어 시퀀스를 겹치는 단어 삼중의 시퀀스로 바꾸는 데 유용합니다.

다음과 같이 하나의 핫 벡터 시퀀스로 인코딩되어야 하는 입력 시퀀스 "a b c 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 0
1 0 1 0
0 1 0 0

참고

이 계층은 기본 형식과 FutureValue() 주변 PastValue() 래퍼입니다.

예제

다음은 세 개의 인접 단어를 삼각 벡터에 쌓는 방법을 보여줍니다.

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): 유추에 사용하기 위해 평균/분산 통계를 계산하는 데 사용되는 1차 로우패스 필터 샘플의 시간 상수입니다.
  • initialScale: 소수 자릿수 매개 변수의 초기 값
  • epsilon: 역을 계산할 때 분산 예측값에 추가되는 작은 값
  • useCntkEngine: true이면 CNTK 네이티브 구현을 사용합니다. false이면 cuDNN의 구현을 사용합니다(GPU에만 해당).

LayerNormalizationLayer:

  • initialScale: 소수 자릿수 매개 변수의 초기 값
  • initialBias: 바이어스 매개 변수의 초기 값

반환 값

정규화 작업을 수행하는 계층을 구현하는 함수입니다.

Description

BatchNormalizationLayer{} 에서는 문서 일괄 처리 정규화: 내부 공변 시프트(세르게이 Ioffe, Christian Szegedy)를 줄여 심층 네트워크 학습 가속화에 설명된 기술을 구현합니다. 미니배치 평균/분산을 통해 모든 미니배치에 대한 입력을 정규화하고 학습된 배율 인수 및 바이어스로 정규화 해제합니다.

추론에서 미니배치 평균/분산을 사용하는 대신 일괄 처리 정규화는 장기 실행 평균/var 추정치를 사용합니다. 이 예상치는 하위 패스 필터링 미니배치 통계를 통해 학습 중에 계산됩니다. 로우 패스 필터의 시간 상수는 매개 변수를 normalizationTimeConstant 통해 수정할 수 있습니다. 기본값(5000)으로 시작하는 것이 좋지만, 일반적으로 수천에서 수만 개의 순서로 다른 값을 실험해 봅니다.

LayerNormalizationLayer{}는 계층 정규화(Jimmy Lei Ba, Jamie Ryan Kiros, Geoffrey E. Hinton)를 구현합니다. 샘플의 모든 요소에서 평균을 빼고 샘플의 모든 요소에 대한 표준 편차로 나누어 각 입력 샘플을 정규화합니다.

StabilizerLayer{} 는 자체 안정화 심층 신경망당 자체 안정화기를 구현합니다(P. Ghahremani, J. Droppo). 간단하지만 효과적인 이 기술은 입력을 학습 가능한 스칼라와 곱합니다(하지만 계층 정규화와 달리 입력을 먼저 정규화하지는 않으며 평균을 빼지도 않음). 선형 스칼라 beta 또는 지수 Exp (beta)를 제안하는 원본 논문과 비교할 때, 두 번째 저자의 제안에 따라 선명하게 하는 softplus 연산을 사용하는 것이 유익하여 지수에서 음수 값과 불안정성을 모두 피할 수 있습니다.

참고

BatchNormalizationLayer{} 는 기본 형식을 둘러싼 BatchNormalization() 래퍼입니다. LayerNormalizationLayer{} 브레 StabilizerLayer{} 인스크립트에서 직접 표현됩니다.

예제

일괄 처리 정규화를 사용하는 나선형 네트워크의 일반적인 계층:

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

매개 변수

빈 인수 목록 {}.

반환 값

정규화 작업을 수행하는 계층을 구현하는 함수입니다.

Description

이 계층은 편향 및 분산에 따라 신경망에 대한 입력을 정규화합니다. 이러한 값은 학습 데이터를 통해 전체 패스를 수행한 다음 저장 및 고정하여 미리 예측됩니다. 이 작업은 자동으로 발생합니다.

이 계층의 매개 변수는 주 학습 전에 별도의 패스로 사전 계산되므로 로 선언된 Input{}변수에만 적용할 수 있습니다.

예제

음성의 음향 모델링을 위한 신경망의 일반적인 시작입니다.

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