BrainScript ile Katmanlar Başvurusu
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`
h1
ve 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 query
doc
ile 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ış boyutuactivation
(DenseLayer{}
yalnızca): etkinleştirme işlevi olarak kullanılacak bir işlevi buraya geçirin; örneğinactivation=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ırbias
: 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 outDim
verilen 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ğinactivation=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ırstride
: Filtreyi giriş üzerinde kaydırırken artırma. Örneğin(2:2)
, boyutları 2 azaltmak içinpad
: 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ırsapad
, 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 numOutputChannels
filtrelere ç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 .W
sona 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 eklemeyinactivation
: isteğe bağlı doğrusal olmayan, örneğinactivation=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ırinitBias
: yanlılık için ilk değerstride
: Filtreyi giriş üzerinde kaydırırken artırma. Örneğin(2:2)
, boyutları 2 azaltmak içinautoPadding
: 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ırsaautoPadding
, 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=true
temel öğ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çinpad
: 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ırsapad
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çinpad
: 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ş p1
konumları ü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 boyutuinit
('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ırembeddingPath
: Varsa, eklemeler öğrenilmez ancak bir dosyadan yüklenir ve eğitim sırasında daha fazla güncelleştirilmeztranspose
: 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 dizisicellShape
( (RecurrentLSTMLayer{}
, isteğe bağlı): LSTM hücresinin boyutu. Normalde bu ile aynıdıroutDim
. 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çinRecurrentLSTMLayer()
gibicellShape
değerler dizisigoBackwards
(isteğe bağlı): True ise yinelenme geriye doğru çalıştırılırusePeepholes
(isteğe bağlı): true ise LSTM'de göz deliği bağlantılarını kullanıninit
('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ırenableSelfStabilization
(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=true
olmak ü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
- projeksiyon yok (parametre yok
allowOptimizedEngine=true
Özellikle, CNTK etkinleştirmesi allowOptimizedEngine=true
gerekir.
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ındefaultHiddenActivation
: 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 ilkspatialRank
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 sabitiinitialScale
: ölçek parametresinin ilk değeriepsilon
: tersini hesaplarken varyans tahminine eklenen küçük değeruseCntkEngine
: 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ğeriinitialBias
: 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)
...