Aracılığıyla paylaş

BrainScript ile Katmanlar Başvurusu

  • Makale

CNTK, bir dizi ortak "katmanı" önceden tanımladığı için, üst üste katmanlanmış standart katmanlardan oluşan basit ağlar yazmayı çok kolaylaştırır. Katmanlar, normal BrainScript işlevleri gibi kullanılabilecek ancak öğrenilebilir parametreleri tutan ve yapı parametrelerini veya özniteliklerini geçirmek için ek bir çifte {} sahip olan işlev nesneleridir.

Örneğin bu, katmanı kullanan basit bir 1 gizli katman modelinin ağ açıklamasıdır DenseLayer{} :

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

bu, örneğin çapraz entropi ölçütlerine karşı eğitim için kullanılabilir:

ce = CrossEntropy (labels, p)

Ağınız işlemlerin düz bir birleştirmesiyse (birçoğu vardır), alternatifini kullanabilirsinizSequential() Gösterim:

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

ve şu şekilde çağır:

p = myModel (features)

Örnek modeller

Aşağıda, bir sözcük dizisi ekleyen, bunu yinelenen bir LSTM ile işleyen ve ardından her sözcüğü sınıflandırır:

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

Görüntü tanıma için basit bir kıvrımlı ağ da aşağıdadır:

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

Parametre paylaşımı

Bir değişkene katman atar ve birden çok yerde kullanırsanız , parametreler paylaşılır. Eğer dediyseniz

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

h1ve h2 her iki durumda da aynı işlev olduğu gibi lay() aynı parametreleri paylaşır. Yukarıdaki durumda bu muhtemelen istenen şey değildir, bu nedenle unutmayın. Yukarıdaki her iki çağrının lay() da farklı parametrelere sahip olması amaçlanıyorsa, ve lay2 = DenseLayer{...}gibi lay1 = DenseLayer{...} iki ayrı örnek tanımlamayı unutmayın.

Peki neden bu davranış? Katmanlar, bir modelin bölümleri arasında parametreleri paylaşmaya olanak sağlar. Aynı işleme zinciriyle ve aynı doc şekilde iki giriş görüntüsü işleyen ve query sonuçta elde edilen gizli vektörleri karşılaştıran bir DSSM modeli düşünün:

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)

burada imageToVec , modelin görüntüleri düz vektöre dönüştüren bölümüdür. imageToVec , birkaç işlev nesnesi (örneğin, üç örneği) içeren bir işlev nesnesidir ConvolutionalLayer{}. imageToVecörneği bir kez oluşturulur ve bu örnek, dahil edilen tüm işlev nesnelerinin öğrenilebilir parametrelerini tutar. her iki çağrısı model() da bu parametreleri uygulamada paylaşır ve bunların gradyanları her iki çağrının toplamı olur.

Son olarak, yukarıdaki örnekteyse query ve doc aynı boyutlara sahip olmalıdır, çünkü bunlar aynı işlev nesnesi aracılığıyla işlenir ve bu işlev nesnesinin ilk katmanının giriş boyutu hem hem de querydocile eşleşecek şekilde çıkarılmıştır. Boyutları farklıysa, bu ağ yanlış biçimlendirilmiş demektir ve boyut çıkarımı/doğrulaması bir hata iletisiyle başarısız olur.

Uygulama notu

Birçok katman, temel CNTK temelleri etrafında sarmalayıcılar ve ilgili gerekli öğrenilebilir parametrelerdir. Örneğin, ConvolutionalLayer{} ilkel öğeyi Convolution() sarmalar. Katmanları kullanmanın avantajları şunlardır:

  • katmanlar doğru boyutta öğrenilebilir parametreler içerir
  • katmanlar birleştirilebilir (cf. Sequential())

DenseLayer{}, LinearLayer{}

Tamamen bağlı bir katman oluşturmak için fabrika işlevi. DenseLayer{} isteğe bağlı doğrusal olmayan bir değer alır.

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

Parametreler

  • outDim: Bu katmanın çıkış boyutu
  • activation (DenseLayer{} yalnızca): etkinleştirme işlevi olarak kullanılacak bir işlevi buraya geçirin; örneğin activation=ReLU
  • init ('heNormal'|'glorotUniform'|...): ağırlıklar için başlatma türü. Başlatma seçeneklerinin tam listesi için buraya bakın.
  • initValueScale: varyans rastgele başlatması bununla çarpılır
  • bias: false ise, sapma parametresi eklemeyin

Dönüş Değeri

İstenen tam bağlı katmanı uygulayan bir işlev. Açıklamaya bakın.

Description

Tam olarak bağlı bir katman oluşturmak için bu fabrika işlevlerini kullanın. Bir etkinleştirme işlevinin eklenmesini istiyorsanız kullanın DenseLayer{} , aksi takdirde LinearLayer{}.

Bu fabrika işlevlerinin her biri, öğrenilebilir bir ağırlık matrisi ve olmadığı sürece bias=false, öğrenilebilir bir sapma içeren bir işlev nesnesi oluşturur. İşlev nesnesi, şu formüllerden birini uygulayan bir işlev gibi kullanılabilir:

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

burada W boyutun [outDim x (dimension of v)]ağırlık matrisidir, b boyutun [outdim]sapmasıdır ve sonuçta elde edilen değer tarafından outDimverilen boyuta (veya tensor boyutlarına) sahiptir.

Tensor desteği

Döndürülen işlev bir tensor derece > 1 girişine uygulanırsa (örneğin, bir 2B görüntü) W boyutuna [outDim x (first dimension of input) x (second dimension of input) x ...]sahip olur.

Öte yandan, outDim tensor boyutlarını belirten bir vektör olabilir, örneğin (10:10). Bu durumda, W boyutuna [outDim[0] x outDim[1] x ... x (dimension of input)]ve b tensor boyutlarına [outDim[0] x outDim[1] x ...]sahip olacaktır.

CNTK matris ürünü, bu ek çıkışı veya giriş boyutlarını uzun bir vektörde düzleştirilmiş gibi yorumlar. Bu konuda daha fazla ayrıntı için Times()

Örnek:

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

veya alternatif olarak:

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

ConvolutionalLayer{}

İsteğe bağlı doğrusal olmayan bir kıvrım katmanı oluşturur.

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

Parametreler

  • numOutputChannels: çıkış kanalı sayısı (filtre sayısı)
  • filterShape: 2B filtre gibi (5:5) bir filtrenin uzamsal kapsamı. Giriş kanalı boyutu buraya dahil edilmeyecek .
  • activation: isteğe bağlı doğrusal olmayan, örneğin activation=ReLU
  • init ('heNormal'|'glorotUniform'|...): ağırlıklar için rastgele başlatma türü. Rastgele başlatma seçeneklerinin tam listesi için buraya bakın.
  • initValueScale: varyans rastgele başlatması bununla çarpılır
  • stride: Filtreyi giriş üzerinde kaydırırken artırma. Örneğin (2:2) , boyutları 2 azaltmak için
  • pad: ayarlanmamışsa (varsayılan), filtre girişin "geçerli" alanı üzerine kaydırılır, yani alan dışında bir değer kullanılmaz. Öte yandan ayarlanırsa pad , filtre tüm giriş konumlarına uygulanır ve geçerli bölge dışındaki değerler sıfır olarak değerlendirilir.
  • lowerPad, upperPad: Doldurma için farklı kenar boşluklarını açıkça belirtin. Filtreler, sıfırlarla (sanal olarak) genişletilmiş geçerli bir bölge üzerinde kaydırılır. lowerPad=(1:2) Örneğin, sıfırlardan oluşan bir sütun ve iki satır sıfır ekler. Çıkışın boyutu buna göre genişletilir.
  • bias: false ise, sapma parametresi eklemeyin

Dönüş Değeri

İstenen tam bağlı katmanı uygulayan bir işlev. Açıklamaya bakın.

Description

Bu fabrika işlevlerini kullanarak bir kıvrım katmanı oluşturun.

Sonuçta elde edilen katman N boyutlu tensöre bir konvolüsyon işlemi uygular. Çağıran, filtrenin uzamsal kapsamını belirtir. Belirli bir uzamsal ölçüdeki bir filtre kümesi (örn. (5:5)) girişin her konumuyla (örn. boyutlu bir [640 x 480]görüntü) ilişkilendirilir. Doldurmanın etkinleştirildiği (pad) ve adımlarının 1 olduğu varsayıldığında, bu aynı boyutta ([640 x 480]) bir çıkış bölgesi oluşturur.

Genellikle birçok filtre aynı anda uygulanır. numOutputChannels sayıyı belirtir, bu nedenle her giriş konumu için vektörünün numOutputChannels tamamı oluşturulur. Yukarıdaki örneğimizde, 64 olarak ayarlanması numOutputChannels boyut tensorunda [640 x 480 x 64]olacaktır. Bu son eksene kanal boyutu adı verilir.

Kanal boyutuna sahip bir girişe konvolüsyon uygulandığında, her filtre girişin kanal boyutunun vektörlerinden de oluşur. Örneğin, belirli bir uzamsal filtre kapsamına (5:5)[640 x 480 x 3]sahip konvolüsyon uygulandığında, her filtre bir [5 x 5 x 3] tensor olur.

Birlikte yığılmış tüm numOutputChannelsfiltrelere çekirdek adı verilir. Örneğimizde çekirdek şekli olacaktır [5 x 5 x 3 x 64].

Aşağıda, çeşitli boyutlar ve şekiller arasındaki ilişki özetlemektedir:

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  ]

örneğimizde aşağıdakiler yer alan:

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  ]

İç Boşluk

Doldurma etkinleştirilmemişse çıkış bölgesi, tam filtre kapsamının uygulanamayacağı sınır konumları tarafından azaltılır. Örneğin, bir görüntüye doldurma olmadan bir uzantı filtresi uygulamak (5:5), en dıştaki 2 satır ve piksel sütunu filtrenin sınırların dışına uygulanmasına neden olabilir. Bu nedenle, ConvolutionalLayer{} boyutları buna göre azaltacaktır.

[640 x 480] Doldurma içermeyen bir filtreyle birleştirilmiş bir (5:5) görüntü, boyutlu bir [636 x 476]çıkış bölgesi bırakır.

Adımlar

stride Parametreler filtrelerin artışını belirtir. Birden büyük adım değerleri çıkış bölgesinin alt örneklemesine yol açar. Örneğin, bir [640 x 480] görüntüyü adım adım (2:2) filtrelemek, doldurmalı ve [318 x 238] doldurmasız boyutlu bir [320 x 240]bölgeyle sonuçlanır.

Notlar

Bu katman, temel öğe etrafında Convolution() bir sarmalayıcıdır.

Günlüğün doğrulama bölümünde gösterildiği gibi filtre çekirdeği parametrelerinin adı ile .Wsona erer. Boyut şu anda yukarıda açıklandığı gibi [ (filterShape) x (#input channels) x numOutputChannels ] gösterilmeyecek, bunun yerine [ numOutputChannels x ((filtre şekli üzerinde ürün) * (#input kanallar)) ]'.

Örnek:

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

DeconvLayer{}

Bir deconvolution katmanı oluşturur.

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}

Parametreler

  • numOutputChannels: çıkış kanalı sayısı (filtre sayısı)
  • filterShape: 2B filtre gibi (5:5) bir filtrenin uzamsal kapsamı. Giriş kanalı boyutu buraya dahil edilmeyecek .
  • numInputChannels: giriş kanalı sayısı (giriş biriminin filtre sayısı)
  • bias: false ise, sapma parametresi eklemeyin
  • activation: isteğe bağlı doğrusal olmayan, örneğin activation=ReLU
  • init ('heNormal'|'glorotUniform'|...): ağırlıklar için rastgele başlatma türü. Rastgele başlatma seçeneklerinin tam listesi için buraya bakın.
  • initValueScale: varyans rastgele başlatması bununla çarpılır
  • initBias: yanlılık için ilk değer
  • stride: Filtreyi giriş üzerinde kaydırırken artırma. Örneğin (2:2) , boyutları 2 azaltmak için
  • autoPadding: ayarlanmamışsa (varsayılan), filtre girişin "geçerli" alanı üzerine kaydırılır, yani alan dışında bir değer kullanılmaz. Öte yandan ayarlanırsa autoPadding , filtre tüm giriş konumlarına uygulanır ve geçerli bölge dışındaki değerler sıfır olarak değerlendirilir.
  • lowerPad, upperPad: Çıkış biriminin doldurması için açıkça farklı kenar boşlukları belirtin ; örneğin, karşılık gelen kıvrımlı katmandaki giriş için kullanılan kenar boşlukları. Aynı tensor boyutlarına ulaşmak için bunları kıvrımlı katmana karşılık olarak ayarlamak önemlidir.

Dönüş Değeri

İstenen tam bağlı katmanı uygulayan bir işlev. Açıklamaya bakın.

Description

Bir deconvolution katmanı oluşturmak için bu fabrika işlevlerini kullanın.

Sonuçta elde edilen katman, N boyutlu tensor üzerinde bir deconvolution işlemi uygular. Bu katman, ile deconv=truetemel öğe etrafında Convolution() bir sarmalayıcıdır.

Deconvolution için popüler kullanım durumlarından biri, bir görüntüyü yeniden yapılandırmaktır (örneğin buraya bakın). Konvolüsyon bir giriş 2B alıcı alan bölgesi alır ve bağıntıyı bir 2B filtre ile hesaplarken, dekonsolasyon bir piksel alır ve bunu bir 2B bölgeye yayar.

Şu içeriğe sahip bir görüntü p(.,.), piksel konumu (x,y) ve ortalanmış [3 x 3] filtreyi göz önünde bulundurun (şimdilik özellik eşleme derinliği boyutu yok, yani tek bir kanal):

[ . . c
  a b .
  . . . ]

Burada b ve c, '.' filtrenin ağırlıklarıdır. Sıfır ağırlığa karşılık gelir. Convolution(), konumdaki (x, y) q(x, y) çıkış pikselini şu şekilde hesaplar:

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

Deconvolution, q(x,y) piksellerini alır ve bunları çevresindeki bir bölgeye (x,y) yayar. Aynı filtreyi kullanırsak r(x,y) çıkışına aşağıdaki katkıları yapar:

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

Aynı şeyin düzlemdeki tüm x ve y için de geçerli olduğunu bilerek bunu r(x,y) için ifade edebiliriz:

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

veya toplamda,

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

Bu, filtrenin her iki eksende de yansıtılması dışında yukarıdaki Convolution ile aynı biçime sahiptir.

Şimdi özellik haritalarını karmaya dahil ediyoruz. Bu kolay: Giriş derinliğinden çıkış derinliğine geçmek yerine diğer yöne gidiyoruz.

Özetle, Convolution (W, x) == Deconvolution (W', x), burada

W : [W x H x C x K]

ve

W’ = W değerleri şu şekilde yeniden düzenlenmiştir: [(W mirrored) x (H mirrored) x K x C]

Yani Deconvolution() örtük olarak şu şekilde yapar:

  • iki derinlik boyutunu değiştirme (dönüşüm)
  • uzamsal boyutlar (verilerin sırasını tersine çevirme)
  • Bunlarla Convolution()

Örnek:

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

Ayrıntılı bir örnek için Bkz. Deconvolution ve Unpooling kullanarak görüntü otomatik kodlayıcı .

MaxPoolingLayer{}, AveragePoolingLayer{}

Maksimum veya ortalama havuz katmanı oluşturmak için fabrika işlevleri.

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

Parametreler

  • poolShape: havuza bölgenin şekli, örneğin (2:2)
  • stride: havuzu giriş üzerinde kaydırırken artırma. Örneğin (2:2) , boyutları 2 azaltmak için
  • pad: ayarlanmamışsa (varsayılan), havuz girişin "geçerli" alanı üzerine kaydırılır, yani alan dışında hiçbir değer kullanılmaz. Diğer yandan ayarlanırsa pad havuz tüm giriş konumlarına uygulanır ve geçerli bölge dışındaki değerler sıfır olarak değerlendirilir. Ortalama havuz için ortalama sayısı, doldurulmuş değerleri içermez.
  • lowerPad, upperPad: Doldurma için farklı kenar boşluklarını açıkça belirtin. Filtreler, sıfırlarla (sanal olarak) genişletilmiş geçerli bir bölge üzerinde kaydırılır. lowerPad=(1:2) Örneğin, sıfırlardan oluşan bir sütun ve iki satır sıfır ekler. Çıkışın boyutu buna göre genişletilir.

Dönüş Değeri

İstenen havuz katmanını uygulayan bir işlev. Açıklamaya bakın.

Description

Havuz işlemi oluşturmak için bu fabrika işlevini kullanın. Havuz alanındaki değerlerin üst sınırını hesaplamak ve AveragePoolingLayer{} bunların ortalamasını almak için kullanınMaxPoolingLayer{}.

Havuz işlemi, giriş bölgesinin konumları üzerinde bir "havuz penceresi" kaydırarak ilgili havuz bölgesindeki değerlerin en yüksek veya ortalamasını hesaplar.

Bu işlem yapısal olarak konvolüsyona çok benzer, ancak kayan pencereye uygulanan işlem farklı bir yapıya sahiptir.

Giriş boyutları, doldurma ve adımlarla ilgili tüm önemli noktalar aynı şekilde uygulanır, bu nedenle daha fazla ayrıntı için lütfen bakın ConvolutionalLayer{} .

Örnek:

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

MaxUnpoolingLayer{}

Maksimum kaldırılmayan bir katman oluşturur.

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

Parametreler

  • poolShape: biriktirilmez bölgenin şekli ( çıkış bölgesi boyutu), örneğin (2:2)
  • stride: Havuzu çıkış üzerinde kaydırırken artırma. Örneğin (2:2) , boyutları 2 artırmak için
  • pad: ayarlanmamışsa (varsayılan), havuz çıkışın "geçerli" alanı üzerine kaydırılır, yani alanın dışında hiçbir değer kullanılmaz.
  • lowerPad, upperPad: Doldurma için farklı kenar boşluklarını açıkça belirtin. Filtreler, (sanal olarak) genişletilmiş geçerli bir çıkış bölgesi olduğunu varsayar.

Dönüş Değeri

İstenen biriktirilmemiş katmanı uygulayan bir işlev. Açıklamaya bakın.

Description

Bir biriktirme işlemi oluşturmak için bu fabrika işlevini kullanın.

Biriktirmeyi kaldırma işlemi, havuza alma işleminin tersidir. İki giriş gerektirir: örneğin, ilgili havuz katmanının p1 çıkışı ve buna karşılık gelen havuz katmanının girişi de (örneğin r1) . Giriş p1konumları üzerinde bir "ters havuz penceresi" kaydırır ve değeri ilgili havuz oluşturma işleminde en yüksek değere sahip olan çıkış bölgesinin bu konumuna (örneğin, içinde r1) projeler. CNTK anahtar değişkenleri olarak adlandırılan değişkenleri depolamadığından CNTK'de biriktirilmeyen işlemin hedefini belirlemek için ikinci giriş r1 gereklidir (ayrıntılar için buraya bakın).

Örnek:

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

Ayrıntılı bir örnek için bkz. Deconvolution ve Unpooling kullanarak görüntü otomatik kodlayıcı .

EmbeddingLayer{}

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

Parametreler

  • outDim: İstenen ekleme vektörünün boyutu
  • init ('heNormal'|'glorotUniform'|...): ağırlıklar için başlatma türü. Başlatma seçeneklerinin tam listesi için buraya bakın.
  • initValueScale: Varyans rastgele başlatması bununla çarpılır
  • embeddingPath: Varsa, eklemeler öğrenilmez ancak bir dosyadan yüklenir ve eğitim sırasında daha fazla güncelleştirilmez
  • transpose: dönüştürülen formda depolanan eklemelerin yüklenmesine izin verir

Dönüş Değeri

Ekleme katmanını uygulayan bir işlev. Açıklamaya bakın.

Description

"Ekleme", sözcükleri veya diğer ayrık öğeleri yoğun sürekli vektörlerle temsil etmeyi ifade eder. Bu katman, girişin tek etkin biçimde olduğunu varsayar. Örneğin, 10.000 sözcük dağarcığı boyutu için her giriş vektörünün 10.000 boyutunda olması ve 1 içeren bir konum dışında sıfırlardan oluşması beklenir. Bu konumun dizini, temsil eden sözcüğün veya öğenin dizinidir.

CNTK'de, karşılık gelen ekleme vektörleri bir matrisin sütunları olarak depolanır. Bu nedenle, bir giriş sözcüğünü ekleme işlemiyle eşleme matris ürünü olarak uygulanır. Bunun çok verimli olması için giriş vektörlerinin seyrek biçimde depolanması önemlidir.

Eğlenceli gerçek: Ekleme matrisinin gradyanı, minibatch içinde görülen sözcükler için yalnızca sıfır olmayan gradyan vektörleri biçimindedir. Onlarca veya yüz binlerce gerçekçi sözcük dağarcığı için sütunların büyük çoğunluğu sıfır olacağından, CNTK uygulamalarında gradyanı "sütun seyrek" biçiminde göstermek için belirli bir iyileştirme vardır.

Bilinen sorun: Yukarıda bahsedilen sütun seyrek gradyan formu şu anda 1 bit SGD paralelleştirme tekniğimiz tarafından desteklenmiyor. Lütfen bunun yerine blok momentum tekniğini kullanın.

Örnek

87636 kelime dağarcığındaki sözcükleri 300 boyutlu vektör olarak temsil eden öğrenilmiş ekleme:

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

öğesine ek olarak sparse=true, bir girişi yapılandırma bloğunda reader seyrek olarak da bildirmelidir. Aşağıda ile seyrek metin girişi okuma örneği verilmiştir CNTKTextFormatReader:

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

Bunun yerine, ekleme vektörleri zaten varsa ve bir dosyadan yüklenmesi gerekiyorsa, şöyle görünür:

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

burada dosyanın "embedding-en.txt" her biri 300 boşlukla ayrılmış sayıdan oluşan 87.636 metin satırına sahip olması beklenir. Bu dosya eklemeleri sütunlar yerine satırlar olarak kaydettiğinden, transpose=true matrisi anında değiştirir.

RecurrentLSTMLayer{}, RecurrentLSTMLayerStack{}

Tek katmanlı veya çok katmanlı yinelenen LSTM oluşturmak için fabrika işlevleri.

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}

Parametreler

  • outDim (RecurrentLSTMLayer{}): ağ çıkışının boyutu. Derece>1'in tensor'ını belirtmek için bu bir vektör olabilir, örneğin. (40:2)
  • layerDims (RecurrentLSTMLayerStack{}): ağın iç katmanlarının ve çıkışının boyut dizisi
  • cellShape ( (RecurrentLSTMLayer{}, isteğe bağlı): LSTM hücresinin boyutu. Normalde bu ile aynıdır outDim. Farklı bir değer verilirse, hücre boyutundan çıkışa dönüştürmek için ek bir doğrusal projeksiyon eklenir.
  • cellShapes( (RecurrentLSTMLayerStack{}, isteğe bağlı): yansıtmayı göstermek için RecurrentLSTMLayer() gibi cellShape değerler dizisi
  • goBackwards (isteğe bağlı): True ise yinelenme geriye doğru çalıştırılır
  • usePeepholes (isteğe bağlı): true ise LSTM'de göz deliği bağlantılarını kullanın
  • init ('heNormal'|'glorotUniform'|...): ağırlıklar için başlatma türü. Başlatma seçeneklerinin tam listesi için buraya bakın.
  • initValueScale: Varyans rastgele başlatması bununla çarpılır
  • enableSelfStabilization (isteğe bağlı): true ise şuna benzer bir "dengeleyici" işlemi ekleyin: StabilizerLayer{}
  • allowOptimizedEngine (isteğe bağlı, varsayılan yanlış): true ise mümkün olduğunda cuDNN'nin iyileştirilmiş RNN altyapısını kullanın

Dönüş Değeri

Giriş sırasına yinelenen bir LSTM uygulayan/uygulayan istenen katmanları uygulayan bir işlev. Bu katman (-stack), giriş dizisini aynı uzunluktaki gizli durum dizisiyle eşler.

Description

Bu, bir giriş dizisine uygulanacak yinelenen LSTM'yi iki değişkende uygular: tek bir katman ve çok katmanlı yığın. Bu işlem, değişken uzunlukta girişi otomatik olarak işler. Gizli durum ve hücrenin başlangıç değeri 0'dır.

Bu katmanın bir giriş dizisine uygulanması, yinelenen (yığının üstü) LSTM'nin gizli durumlarının sırasını döndürür (LSTM'nin bellek hücresinin değeri döndürülmedi). Döndürülen sıra girişle aynı uzunluktadır. Dizi sınıflandırmasında veya bazı sıralı senaryolarda olduğu gibi yalnızca son durum isteniyorsa, yalnızca son öğenin gizli durumunu ayıklamak için kullanın BS.Sequences.Last() . (Geriye dönük yinelenmede kullanabilirsiniz BS.Sequences.First().)

ile RecurrentLSTMLayer()çift yönlü model oluşturmak için, biri ile goBackwards=trueolmak üzere iki katman ve Splice() iki çıkışı birlikte kullanın. RecurrentLSTMLayerStack() şu anda çift yönlü modelleri desteklemez, birden çok RecurrentLSTMLayer()/Splice() birleşik giriş kullanarak el ile oluşturmanız gerekir.

CuDNN5 RNN altyapısını kullanma

Bu işlev mümkünse CuDNN5'in iyileştirilmiş RNN altyapısını otomatik olarak kullanır.

  • belirtilen model CuDNN5'in işlevi tarafından uygulanabilen modeldir
    • projeksiyon yok (parametre yok cellShape )
    • peep-hole bağlantısı yok
    • kendi kendine dengeleme yok
    • geriye doğru gitme
    • için RecurrentLSTMLayerStack{}, tüm katman boyutları aynı değere sahiptir
  • allowOptimizedEngine=true

Özellikle, CNTK etkinleştirmesi allowOptimizedEngine=truegerekir. Bunun nedeni CuDNN5 RNN'nin GPU gerektiren CNTK temel bir işlem olarak uygulanmasıdır. Bununla birlikte, birçok gerçek sistem gpu'ları eğitim için kullanır ancak dağıtımda yalnızca CPU sunucuları kullanır. CuDNN5 RNN burada uygun değildir. (Eğitim için Teorik olarak CuDNN5 RNN'yi kullanmak ve dağıtım için bunu BrainScript'te eşdeğer bir açık LSTM uygulamasıyla bir düzenleme işlemiyle değiştirmek mümkündür.)

Notlar

Daha allowOptimizedEngine=true sonra bu iki katman değişkeni ilkelin OptimizedRNNStack() etrafındaki sarmalayıcılardır.

Örnek

Bir yinelenme aracılığıyla bir sözcük dizisi çalıştıran ve ardından LSTM'nin son gizli durumunu softmax sınıflandırıcısına geçiren basit bir metin sınıflandırıcısı şu forma sahip olabilir:

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

Yukarıdaki örneği CuDNN5 RNN altyapısını kullanan 3 katmanlı bir yığınla değiştirmek için şu satırı değiştirin:

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

Çift yönlü bir tek katmanlı LSTM oluşturmak için (örneğin, yukarıdakine kıyasla gizli boyutun yarısını kullanarak), şunu kullanın:

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

DelayLayer{}

Girişini geciktiren bir katman oluşturmak için factory işlevi.

DelayLayer {T=1, defaultHiddenActivation=0}

Parametreler

  • T: geciktirme adımlarının sayısı. Gelecekteki değerlere erişmek için negatif bir değer kullanın
  • defaultHiddenActivation: sınırlarda gecikmeli çerçeveler için kullanılacak değer

Dönüş Değeri

İstenen gecikme işlemini uygulayan bir işlev.

Description

Bu işlem, giriş dizisini adımlara göre T geciktirir (varsayılan 1). Bu, örneğin, bir sözcük dizisini çakışan sözcük üçlüleri dizisine dönüştürmek için kullanışlıdır.

Aşağıdaki gibi tek etkin vektör dizisi olarak kodlanacak bir "a b c b" giriş dizisini göz önünde bulundurun:

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

Burada, her sütun tek etkin bir vektördür ve bir sözcümeye karşılık gelir. DelayLayer{T=1} Bu girişe uygulanması şu sırayı oluşturur:

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

Tüm belirteçler bir gecikir ve ilk konum 0 vektör olarak doldurulur. Benzer şekilde, (negatif gecikme) kullanılması DelayLayer{T=-1} gelecekteki değerlere erişim verir ve sağdan sıfır ile doldurulur:

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

Notlar

Bu katman, ve FutureValue() temel öğelerinin PastValue() etrafındaki bir sarmalayıcıdır.

Örnek

Aşağıda üç komşu sözcüğün bir trigram vektöre nasıl yığılma gösterilmektedir:

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

Toplu normalleştirme, katman normalleştirme ve kendi kendine dengeleme için katmanlar oluşturmaya yönelik fabrika işlevleri.

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

Parametreler

BatchNormalizationLayer:

  • spatialRank: normalleştirme parametreleri ilk spatialRank boyutlar üzerinde havuza alır. Şu anda izin verilen değerler 0 (havuz yok) ve 2 'tir (görüntünün tüm piksel konumlarında havuz oluşturma)
  • normalizationTimeConstant (varsayılan 5000): çıkarımda kullanım için ortalama/varyans istatistiklerini hesaplamak için kullanılan birinci sırada düşük geçiş filtresi örneklerinde zaman sabiti
  • initialScale: ölçek parametresinin ilk değeri
  • epsilon: tersini hesaplarken varyans tahminine eklenen küçük değer
  • useCntkEngine: true ise, CNTK yerel uygulamasını kullanın. False ise cuDNN uygulamasını kullanın (yalnızca GPU).

LayerNormalizationLayer:

  • initialScale: ölçek parametresinin ilk değeri
  • initialBias: sapma parametresinin ilk değeri

Dönüş Değeri

Normalleştirme işlemini gerçekleştiren bir katman uygulayan işlev.

Description

BatchNormalizationLayer{} Kağıt Batch Normalleştirmesinde açıklanan tekniği uygular: İç Kovaryat Vardiyasını Azaltarak Derin Ağ Eğitimini Hızlandırma (Sergey Ioffe, Christian Szegedy). Her minibatch için girişlerini minibatch ortalaması/varyansı ile normalleştirir ve öğrenilen bir ölçeklendirme faktörü ve sapma ile normalleştirir.

Çıkarım olarak, minibatch ortalaması/varyansı kullanmak yerine toplu normalleştirme uzun süreli çalışan bir ortalama/var tahmini kullanır. Bu tahmin, eğitim sırasında düşük geçişli filtreleme minibatch istatistikleri tarafından hesaplanır. Düşük geçişli filtrenin zaman sabiti parametresi tarafından normalizationTimeConstant değiştirilebilir. Varsayılan değeriyle (5000) başlamanızı öneririz, ancak genellikle birkaç bin ile on bin arasında sırasıyla diğer değerlerle denemeler yapın.

LayerNormalizationLayer{}Katman Normalleştirmesi uygular (Jimmy Lei Ba, Jamie Ryan Kiros, Geoffrey E. Hinton). Her giriş örneğini normalleştirir, örneğin tüm öğeleri arasında ortalamayı çıkarır ve ardından standart sapmaya göre örneğin tüm öğelerine böler.

StabilizerLayer{} Kendi kendine sabitlenmiş derin sinir ağı (P. Ghahremani, J. Droppo) başına kendi kendine dengeleyici uygular. Bu basit ama etkili teknik, girdisini öğrenilebilir bir skaler ile çarpar (ancak katman normalleştirmesinin aksine, önce girişi normalleştirmez veya ortalamayı çıkarmaz). Doğrusal bir skaler veya üstel bir skaler beta öneren özgün kağıtla karşılaştırıldığında, ikinci yazarın Exp (beta)önerisine göre hem negatif değerleri hem de üstelden gelen dengesizlikleri önleyen keskinleştirilmiş bir softplus işlemi kullanmayı yararlı bulduğumuzu unutmayın.

Notlar

BatchNormalizationLayer{} , ilkelin BatchNormalization() etrafındaki bir sarmalayıcıdır. LayerNormalizationLayer{} ve StabilizerLayer{} doğrudan BrainScript'te ifade edilir.

Örnek

Toplu normalleştirme ile kıvrımlı bir ağda tipik bir katman:

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

Özellik girişini ortalama ve standart sapmalarına göre normalleştiren bir katman oluşturmak için factory işlevi.

FeatureMVNLayer{}

Parametreler

Boş bağımsız değişken listesi {}.

Dönüş Değeri

Normalleştirme işlemini gerçekleştiren bir katman uygulayan işlev.

Description

Bu katman, bir sinir ağına yapılan girişi yanlılığı ve varyansı ile normalleştirir. Bu değerler, eğitim verilerinden tam geçiş gerçekleştirilerek önceden tahmin edilir ve ardından kaydedilir ve dondurulur. Bu otomatik olarak gerçekleşir.

Bu katmanın parametreleri ana eğitimden önce ayrı bir geçişte önceden derlendiğinden, yalnızca olarak Input{}bildirilen değişkenlere uygulanabilir.

Örnek

Bu, akustik konuşma modellemesi için sinir ağının tipik bir başlangıcıdır:

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