Útmutató a Net# neurális hálózat specifikációs nyelvéhez a Machine Learning Studióhoz (klasszikus)

ÉRVÉNYES: Machine Learning Studio (klasszikus) Azure Machine Learning

Fontos

A (klasszikus) Machine Learning Studio támogatása 2024. augusztus 31-én megszűnik. Javasoljuk, hogy addig térjen át az Azure Machine Learning használatára.

2021. december 1-től kezdve nem fog tudni létrehozni új (klasszikus) Machine Learning Studio-erőforrásokat. 2024. augusztus 31-ig továbbra is használhatja a meglévő (klasszikus) Machine Learning Studio-erőforrásokat.

• A gépi tanulási projektek ML Studióból (klasszikus) Azure Machine Learningbe való áthelyezéséről szóló információk.
• További információ az Azure Machine Learningről

A (klasszikus) ML Studio dokumentációjának kivezetése folyamatban van, és a jövőben nem várható a frissítése.

A Net# a Microsoft által kifejlesztett nyelv, amely összetett neurális hálózati architektúrák, például mély neurális hálózatok vagy tetszőleges dimenziók konvolúcióinak meghatározására szolgál. Összetett struktúrákkal fejlesztheti az adatok, például a kép, a videó vagy a hang tanulását.

A Net#-architektúra specifikációja a Machine Learning Studio összes neurális hálózati moduljában használható (klasszikus):

• Többosztályos neurális hálózat
• Kétosztályos neurális hálózat
• Neurális hálózati regresszió

Ez a cikk azokat az alapfogalmakat és szintaxist ismerteti, amelyek egy egyéni neurális hálózat Net#használatával történő fejlesztéséhez szükségesek:

• Neurális hálózati követelmények és az elsődleges összetevők meghatározása
• A Net# specifikáció nyelvének szintaxisa és kulcsszavak
• Példák a Net használatával létrehozott egyéni neurális hálózatokra#

A neurális hálózat alapjai

A neurális hálózati struktúra rétegekbe rendezett csomópontokból és a csomópontok közötti súlyozott kapcsolatokból (vagy élekből) áll. A kapcsolatok irányítottak, és minden kapcsolathoz tartozik egy forráscsomópont és egy célcsomópont.

Minden betanítható réteg (rejtett vagy kimeneti réteg) egy vagy több kapcsolatcsomaggal rendelkezik. A kapcsolatcsomagok egy forrásrétegből és az adott forrásrétegből származó kapcsolatok specifikációjából állnak. Az adott csomag összes kapcsolata megosztja a forrás- és célrétegeket. A Net#-ban a kapcsolati köteg a csomag célrétegéhez tartozik.

A Net# különböző típusú kapcsolatcsomagokat támogat, amelyek lehetővé teszik a bemenetek rejtett rétegekhez való leképezésének és a kimenetekhez való leképezésének testreszabását.

Az alapértelmezett vagy standard csomag egy teljes csomag, amelyben a forrásréteg minden csomópontja csatlakozik a célréteg minden csomóponthoz.

A Net# emellett a következő négy speciális kapcsolatcsomagot támogatja:

• Szűrt csomagok. A predikátumot a forrásréteg-csomópont és a célréteg csomópontjának helyével határozhatja meg. A csomópontok akkor csatlakoznak, ha a predikátum igaz.

• Konvolúciós kötegek. A forrásrétegben a csomópontok kis körzeteit definiálhatja. A célréteg minden csomópontja a forrásréteg csomópontjainak egy-egy szomszédságához csatlakozik.

• Csomagok és válasz normalizálási csomagok készletezése. Ezek hasonlóak a konvolúciós kötegekhez, amelyekben a felhasználó a forrásrétegben lévő csomópontok kis körzeteit határozza meg. A különbség az, hogy az ezekben a kötegekben lévő élek súlya nem tanítható. Ehelyett egy előre definiált függvény lesz alkalmazva a forráscsomópont értékeire a célcsomópont értékének meghatározásához.

Támogatott testreszabások

A Machine Learning Studióban (klasszikus) létrehozott neurális hálózati modellek architektúrája széles körben testre szabható a Net#használatával. A következőket teheti:

• Hozzon létre rejtett rétegeket, és szabályozza az egyes rétegek csomópontjainak számát.
• Adja meg, hogy a rétegek hogyan legyenek egymáshoz csatlakoztatva.
• Speciális kapcsolati struktúrák, például konvolúciók és súlymegosztási csomagok definiálása.
• Adjon meg különböző aktiválási függvényeket.

A specifikáció nyelvszintaxisának részleteiért lásd a Structure Specification (Struktúra specifikációja) című témakört.

Példák a neurális hálózatok meghatározására néhány gyakori gépi tanulási feladathoz a simplextől az összetettig, lásd a példákat.

Általános követelmények

• Pontosan egy kimeneti rétegnek, legalább egy bemeneti rétegnek és nulla vagy több rejtett rétegnek kell lennie.
• Minden réteg fix számú csomóponttal rendelkezik, elméletileg tetszőleges dimenziók négyszögletes tömbjében rendezve.
• A bemeneti rétegek nem rendelkeznek társított betanított paraméterekkel, és azt a pontot jelölik, ahol a példányadatok belépnek a hálózatba.
• A betanítható rétegek (a rejtett és kimeneti rétegek) betanított paraméterekkel rendelkeznek, amelyeket súlyoknak és torzításoknak neveznek.
• A forrás- és célcsomópontoknak külön rétegekben kell lenniük.
• A kapcsolatoknak aciklikusnak kell lenniük; más szóval nem lehet a kezdeti forráscsomóponthoz visszavezető kapcsolatlánc.
• A kimeneti réteg nem lehet egy kapcsolatcsomag forrásrétege.

Struktúra-specifikációk

A neurális hálózati struktúra specifikációja három részből áll: az állandó deklarációból, a rétegdeklarációból, a kapcsolati deklarációból. Van egy választható megosztás-deklarálási szakasz is. A szakaszok tetszőleges sorrendben megadhatók.

Állandó deklaráció

Az állandó deklaráció nem kötelező. A neurális hálózat definíciójában máshol használt értékek definiálására szolgál. A deklarációs utasítás egy azonosítóból, majd egy egyenlőségjelből és egy értékkifejezésből áll.

A következő utasítás például konstanst xhatároz meg:

Const X = 28;

Két vagy több állandó egyidejű definiálásához csatolja az azonosítóneveket és az értékeket kapcsos zárójelekbe, és pontosvesszőkkel elválasztja őket. Példa:

Const { X = 28; Y = 4; }

Az egyes hozzárendelési kifejezések jobb oldala lehet egész szám, valós szám, logikai érték (Igaz vagy Hamis) vagy matematikai kifejezés. Példa:

Const { X = 17 * 2; Y = true; }

Rétegdeklaráció

A réteg deklarációja kötelező. Meghatározza a réteg méretét és forrását, beleértve a kapcsolati kötegeket és attribútumokat. A deklarációs utasítás a réteg nevével kezdődik (bemenet, rejtett vagy kimenet), majd a réteg méretei (pozitív egész számok száma). Példa:

input Data auto;
hidden Hidden[5,20] from Data all;
output Result[2] from Hidden all;

• A dimenziók szorzata a rétegben lévő csomópontok száma. Ebben a példában két dimenzió van [5,20], ami azt jelenti, hogy a rétegben 100 csomópont található.
• A rétegek bármilyen sorrendben deklarálhatók, egyetlen kivétellel: Ha egynél több bemeneti réteg van definiálva, a deklarálás sorrendjének meg kell egyeznie a bemeneti adatok funkcióinak sorrendjével.

Ha meg szeretné adni, hogy egy réteg csomópontjainak száma automatikusan meg legyen határozva, használja a kulcsszót auto . A auto kulcsszónak különböző hatásai vannak a rétegtől függően:

• A bemeneti réteg deklarációjában a csomópontok száma a bemeneti adatok funkcióinak száma.
• Rejtett réteg deklarációjában a csomópontok száma a rejtett csomópontok számának paraméterértéke által megadott szám.
• A kimeneti réteg deklarációjában a csomópontok száma 2 a kétosztályos besoroláshoz, 1 a regresszióhoz, és egyenlő a többosztályos besorolás kimeneti csomópontjainak számával.

A következő hálózati definíció például lehetővé teszi az összes réteg méretének automatikus meghatározását:

input Data auto;
hidden Hidden auto from Data all;
output Result auto from Hidden all;

Egy betanítható réteg rétegdeklarációja (a rejtett vagy kimeneti rétegek) opcionálisan tartalmazhatják a kimeneti függvényt (más néven aktiválási függvényt), amely alapértelmezés szerint szigmoid a besorolási modellekhez, és lineáris a regressziós modellekhez. Ha az alapértelmezettet használja is, explicit módon is megadhatja az aktiválási függvényt, ha szeretné, hogy egyértelmű legyen.

A következő kimeneti függvények támogatottak:

• szigmoid
• lineáris
• softmax
• rlinear
• négyzet
• sqrt
• srlinear
• Abs
• tanh
• brlinear

A következő deklaráció például a softmax függvényt használja:

output Result [100] softmax from Hidden all;

Kapcsolati deklaráció

Közvetlenül a betanítható réteg definiálása után deklarálnia kell a kapcsolatokat a definiált rétegek között. A kapcsolatcsomag deklarációja a kulcsszóval fromkezdődik, majd a köteg forrásrétegének neve és a létrehozandó kapcsolatcsomag típusa.

Jelenleg ötféle kapcsolatcsomag támogatott:

• Teljes csomagok, a kulcsszó jelzi all
• Szűrt csomagok, amelyeket a kulcsszó wherejelöl, majd egy predikátumkifejezés
• Konvolúciós kötegek, amelyeket a kulcsszó convolvejelöl, majd a konvolúciós attribútumok
• Készletcsomagok készletezése a maximális készlet vagy középkészlet kulcsszavakkal
• Válasz normalizálási csomagok, amelyeket a kulcsszó-válasz norma jelez

Teljes csomagok

A teljes kapcsolatcsomag tartalmazza a forrásréteg minden csomópontja és a célréteg minden csomópontja közötti kapcsolatot. Ez az alapértelmezett hálózati kapcsolattípus.

Szűrt csomagok

A szűrt kapcsolatcsomag specifikációja tartalmaz egy szintaktikailag kifejezett predikátumot, hasonlóan egy C# lambda kifejezéshez. Az alábbi példa két szűrt csomagot határoz meg:

input Pixels [10, 20];
hidden ByRow[10, 12] from Pixels where (s,d) => s[0] == d[0];
hidden ByCol[5, 20] from Pixels where (s,d) => abs(s[1] - d[1]) <= 1;

• A predikátumban ByRows a bemeneti réteg Pixelscsomópontjainak négyszögletes tömbjére mutató indexet képviselő paraméter, amely d egy indexet jelöl a rejtett réteg csomópontjainak tömbjében. ByRow A kettő s típusa és d a két hosszúságú egész számok száma. Elméletileg s a tartományok az összes egész számpárra 0 <= s[1] < 200 <= s[0] < 10 és a , és d a tartományokra az összes egész számpáron, a következővel és .0 <= d[0] < 10 0 <= d[1] < 12

• A predikátum kifejezés jobb oldalán van egy feltétel. Ebben a példában minden olyan értéknél s d , amelynél a feltétel Igaz, a forrásréteg csomópontjától a célréteg csomópontig van egy él. Ez a szűrőkifejezés tehát azt jelzi, hogy a köteg tartalmaz egy kapcsolatot a csomópont által s meghatározott csomópontról a csomóponttal, amelyet d minden olyan esetben meghatároz, ahol az s[0] értéke d[0].

Igény szerint megadhat súlyokat a szűrt csomagokhoz. A Súlyozás attribútum értékének olyan lebegőpontos értékeknek kell lennie, amelyek hossza megegyezik a köteg által meghatározott kapcsolatok számával. Alapértelmezés szerint a súlyok véletlenszerűen jönnek létre.

A súlyértékek a célcsomópont-index szerint vannak csoportosítva. Vagyis ha az első célcsomópont K forráscsomópontokhoz csatlakozik, a Súlyok rekord első K eleme az első célcsomópont súlyozása, forrásindex-sorrendben. Ugyanez vonatkozik a többi célcsomópontra is.

A súlyokat közvetlenül állandó értékekként is meg lehet adni. Ha például korábban megtanulta a súlyokat, konstansként is megadhatja őket a szintaxis használatával:

const Weights_1 = [0.0188045055, 0.130500451, ...]

Konvolúciós kötegek

Ha a betanítási adatok homogén struktúrával rendelkeznek, a konvolúciós kapcsolatokat gyakran használják az adatok magas szintű jellemzőinek megismerésére. A kép-, hang- vagy videoadatokban például a térbeli vagy időbeli dimenzió meglehetősen egységes lehet.

A konvolúciós kötegek téglalap alakú kerneleket használnak, amelyek átcsúsznak a dimenziókon. Az egyes kernelek lényegében a helyi környezetekben alkalmazott súlyokat határozzák meg, más néven kernelalkalmazásokat. Minden kernelalkalmazás a forrásréteg egy csomópontjának felel meg, amelyet központi csomópontnak neveznek. A kernel súlyozása számos kapcsolat között meg van osztva. Egy konvolúciós kötegben mindegyik kernel téglalap alakú, és minden kernelalkalmazás mérete megegyezik.

A konvolúciós csomagok a következő attribútumokat támogatják:

Az InputShape a forrásréteg dimenzióját határozza meg a konvolúciós köteg szempontjából. Az értéknek pozitív egész számok számának kell lennie. Az egész számok szorzatának meg kell egyeznie a forrásréteg csomópontjainak számával, ellenkező esetben azonban nem kell megegyeznie a forrásréteghez deklarált dimenzióval. Ennek a rekordnak a hossza lesz a konvolúciós köteg aritási értéke. Az aritás általában azon argumentumok vagy operandusok számát jelenti, amelyeket egy függvény el tud venni.

A kernelek alakjának és helyének meghatározásához használja a KernelShape, Stride, Padding, LowerPad és UpperPad attribútumokat:

• KernelShape: (kötelező) Meghatározza az egyes kernelek dimenzióját a konvolúciós köteghez. Az értéknek pozitív egész számoknak kell lennie, amelyek hossza megegyezik a köteg aritásával. Ennek a rekordnak minden összetevője nem lehet nagyobb, mint az InputShape megfelelő összetevője.

• Stride: (nem kötelező) A konvolúció (minden dimenzióhoz egy lépésméret) csúsztatási lépésméretét határozza meg, azaz a központi csomópontok közötti távolságot. Az értéknek pozitív egész számoknak kell lennie, amelyek hossza a köteg aritása. Ennek a rekordnak minden összetevője nem lehet nagyobb, mint a KernelShape megfelelő összetevője. Az alapértelmezett érték egy rekord, amelyben az összes összetevő egyenlő egytel.

• Megosztás: (nem kötelező) Meghatározza a konvolúció minden dimenziójának súlymegosztását. Az érték lehet egyetlen logikai érték, vagy a köteg aritását jelző hosszúságú logikai érték. Egyetlen logikai érték a megfelelő hosszúságú rekordra van kiterjesztve, és az összes összetevő megegyezik a megadott értékkel. Az alapértelmezett érték egy rekord, amely az összes Igaz értékből áll.

• MapCount: (nem kötelező) Meghatározza a konvolúciós csomag funkciótérképeinek számát. Az érték lehet egyetlen pozitív egész szám vagy egy csomó pozitív egész szám, amelynek hossza a köteg aritása. Egyetlen egész szám a megfelelő hosszúságú rekordra van kiterjesztve, az első összetevők pedig megegyeznek a megadott értékkel, a fennmaradó összetevők pedig egy értékkel. Az alapértelmezett érték egy. A funkciótérképek teljes száma a rekord összetevőinek szorzata. Az összetevők teljes számának faktorálása határozza meg, hogy a funkciótérkép értékei hogyan vannak csoportosítva a célcsomópontokban.

• Súlyok: (nem kötelező) Meghatározza a csomag kezdeti súlyait. Az értéknek olyan lebegőpontos értékekből álló rekordnak kell lennie, amelynek hossza a kernelek számának a kernelenkénti súlyok számának megszorozása, a jelen cikk későbbi részében meghatározottak szerint. Az alapértelmezett súlyok véletlenszerűen jönnek létre.

A párnázást két tulajdonságkészlet vezérli, amelyek kölcsönösen kizárják a tulajdonságokat:

• Kitöltés: (nem kötelező) Meghatározza, hogy a bemenetet egy alapértelmezett kitöltési sémával kell-e kipárnázni. Az érték lehet egyetlen logikai érték, vagy lehet a köteg aritását jelző hosszúságú logikai értékek rekordja.

  Egyetlen logikai érték a megfelelő hosszúságú rekordra van kiterjesztve, és az összes összetevő megegyezik a megadott értékkel.

  Ha egy dimenzió értéke Igaz, a forrás logikailag ki van jelölve ebben a dimenzióban nulla értékű cellákkal, hogy további kernelalkalmazásokat támogatjon, így a dimenzió első és utolsó kernelének központi csomópontjai az első és utolsó csomópontok a forrásrétegben. Így az egyes dimenziókban lévő "dummy" csomópontok száma automatikusan meg lesz határozva, hogy pontosan (InputShape[d] - 1) / Stride[d] + 1 illeszkedjenek a magok a párnázott forrásrétegbe.

  Ha egy dimenzió értéke Hamis, a rendszermagok úgy vannak definiálva, hogy a kihagyott csomópontok száma mindkét oldalon azonos legyen (1-es különbségig). Ennek az attribútumnak az alapértelmezett értéke egy rekord, amelyben az összes összetevő értéke Hamis.

• UpperPad és LowerPad: (nem kötelező) Nagyobb vezérlést biztosít a használandó padding mennyisége felett. Fontos: Ezek az attribútumok akkor és csak akkor határozhatók meg, ha a fenti Padding tulajdonság nincs definiálva. Az értékeknek egész szám értékűnek kell lenniük, amelyek hossza a köteg aritása. Ha ezek az attribútumok meg vannak adva, a rendszer "dummy" csomópontokat ad hozzá a bemeneti réteg minden dimenziójának alsó és felső végéhez. Az egyes dimenziók alsó és felső végeihez hozzáadott csomópontok számát a LowerPad[i] és a UpperPad[i] határozza meg.

  Annak érdekében, hogy a kernelek csak a "valódi" csomópontoknak feleljenek meg, és ne a "dummy" csomópontoknak, a következő feltételeknek kell teljesülniük:

  • A LowerPad minden összetevőjének szigorúan kisebbnek kell lennie, mint KernelShape[d]/2.

  • A UpperPad minden összetevője nem lehet nagyobb, mint KernelShape[d]/2.

  • Ezeknek az attribútumoknak az alapértelmezett értéke egy 0-val egyenlő összes összetevővel rendelkező rekord.

    A Padding = true beállítás annyi paddingot tesz lehetővé, amennyi szükséges ahhoz, hogy a kernel "középpontja" a "valódi" bemeneten belül maradjon. Ez egy kicsit megváltoztatja a matematikai számítást a kimeneti méret kiszámításához. A D kimeneti méretet általában úgy számítjuk ki, hogy D = (I - K) / S + 1– ahol I a bemeneti méret K – a kernel mérete, S a lépték, és / egész osztás (nulla felé kerekítve). Ha az UpperPad = [1, 1] értéket állítja be, a bemeneti méret I gyakorlatilag 29, és így D = (29 - 5) / 2 + 1 = 13. Azonban, ha padding = igaz, lényegében I lesz ütközött fel K - 1; így D = ((28 + 4) - 5) / 2 + 1 = 27 / 2 + 1 = 13 + 1 = 14. Az UpperPad és a LowerPad értékeinek megadásával sokkal jobban szabályozhatja a paddingot, mint ha csak a Padding = true értéket állítja be.

A konvolúciós hálózatokról és alkalmazásukról az alábbi cikkekben talál további információt:

• http://d2l.ai/chapter_convolutional-neural-networks/lenet.html
• https://research.microsoft.com/pubs/68920/icdar03.pdf

Kötegek készletezése

A készletezési köteg a konvolúciós kapcsolathoz hasonló geometriát alkalmaz, de előre definiált függvényeket használ a csomópontértékek forrásához a célcsomópont értékének kiszámításához. Ezért a készletezési kötegek nem rendelkeznek betanítható állapottal (súlyokkal vagy torzításokkal). A kötegek készletezése a Megosztás, a MapCount és a Súlyok kivételével minden konvolúciós attribútumot támogat.

A szomszédos készletezési egységek által összegzett kernelek általában nem fedik egymást. Ha a Stride[d] minden dimenzióban megegyezik a KernelShape[d] értékével, akkor a kapott réteg a hagyományos helyi készletezési réteg, amelyet gyakran használnak konvolúciós neurális hálózatokban. Minden célcsomópont kiszámítja a kernel tevékenységeinek maximális vagy középértékét a forrásrétegben.

Az alábbi példa egy készletezési csomagot mutat be:

hidden P1 [5, 12, 12]
  from C1 max pool {
  InputShape  = [ 5, 24, 24];
   KernelShape = [ 1,  2,  2];
   Stride      = [ 1,  2,  2];
  }

• A köteg aritása 3: azaz a csuplok InputShapehossza , KernelShapeés Stride.
• A forrásréteg csomópontjainak száma.5 * 24 * 24 = 2880
• Ez egy hagyományos helyi készletezési réteg, mert a KernelShape és a Stride egyenlő.
• A célréteg csomópontjainak száma.5 * 12 * 12 = 1440

A rétegek készletezésével kapcsolatos további információkért tekintse meg az alábbi cikkeket:

• https://www.cs.toronto.edu/~hinton/absps/imagenet.pdf (3.4. szakasz)
• https://cs.nyu.edu/~koray/publis/lecun-iscas-10.pdf
• https://cs.nyu.edu/~koray/publis/jarrett-iccv-09.pdf

Válasz normalizálási csomagok

A válasz normalizálása egy helyi normalizálási séma, amelyet először a Geoffrey Hinton és munkatársai vezettek be az ImageNet Classification with Deep Convolutional Neural Networks (Mély konvolúciós neurális hálózatok) című tanulmányban.

A válasz normalizálása a neurális hálók általánosításának elősegítésére szolgál. Amikor egy neuron nagyon magas aktiválási szinten aktiválódik, a helyi válasz normalizálási réteg elnyomja a környező neuronok aktiválási szintjét. Ez három paraméter (αés β) és kegy konvolúciós struktúra (vagy szomszédsági alakzat) használatával történik. A célréteg y minden neuronja egy x neuronnak felel meg a forrásrétegben. Az y aktiválási szintjét a következő képlet adja meg, ahol f egy neuron aktiválási szintje, és Nx a kernel (vagy az x szomszédságában található neuronokat tartalmazó készlet), amelyet a következő konvolúciós struktúra határoz meg:

A válasz normalizálási csomagok a Megosztás, a MapCount és a Súlyok kivételével minden konvolúciós attribútumot támogatnak.

• Ha a kernel neuronokat tartalmaz az x térképen, a normalizálási sémát ugyanaznak a térkép-normalizálásnak nevezzük. Ugyanazon térkép normalizálásának meghatározásához az InputShape első koordinátájának 1 értékkel kell rendelkeznie.

• Ha a kernel az x-hez hasonló térbeli pozícióban lévő neuronokat tartalmaz, de a neuronok más térképeken találhatók, a normalizálási sémát a térképek normalizálása során hívjuk meg. Ez a fajta válasz normalizálás implementálja az oldalirányú gátlás egy formáját, amelyet a valódi neuronokban talált típus inspirál, és versenyhelyzetet teremt a különböző térképeken kiszámított neuron-kimenetek nagy aktiválási szintjeiért. A térképek közötti normalizálás meghatározásához az első koordinátának egynél nagyobb egész számnak kell lennie, és nem lehet nagyobb a térképek számánál, a többi koordinátának pedig 1 értékkel kell rendelkeznie.

Mivel a válasz normalizálási csomagok előre definiált függvényt alkalmaznak a forráscsomópont értékeire a célcsomópont értékének meghatározásához, nincs betanítható állapotuk (súlyok vagy torzítások).

Feljegyzés

A célréteg csomópontjai a kernelek központi csomópontjait képező neuronoknak felelnek meg. Ha például páratlan, KernelShape[d] akkor KernelShape[d]/2 a központi kernelcsomópontnak felel meg. Ha KernelShape[d] páros, a központi csomópont a következő helyen KernelShape[d]/2 - 1van: . Ezért ha Padding[d] hamis, az első és az utolsó KernelShape[d]/2 csomópont nem rendelkezik megfelelő csomópontokkal a célrétegben. A helyzet elkerülése érdekében a paddingot [igaz, igaz, ..., igaz] értékként definiálja.

A korábban ismertetett négy attribútum mellett a válasz normalizálási csomagok a következő attribútumokat is támogatják:

• Alfa: (kötelező) Az előző képletnek megfelelő α lebegőpontos értéket adja meg.
• Bétaverzió: (kötelező) Az előző képletnek megfelelő β lebegőpontos értéket adja meg.
• Eltolás: (nem kötelező) Az előző képletnek megfelelő k lebegőpontos értéket adja meg. Alapértelmezés szerint 1.

Az alábbi példa egy válasz normalizálási csomagot határoz meg az alábbi attribútumok használatával:

hidden RN1 [5, 10, 10]
from P1 response norm {
  InputShape  = [ 5, 12, 12];
  KernelShape = [ 1,  3,  3];
  Alpha = 0.001;
  Beta = 0.75;
  }

• A forrásréteg öt térképet tartalmaz, amelyek mérete 12x12, összesen 1440 csomópontban.
• A KernelShape értéke azt jelzi, hogy ez ugyanaz a térkép normalizálási rétege, ahol a környék egy 3x3 téglalap.
• A padding alapértelmezett értéke Hamis, így a célrétegnek csak 10 csomópontja van minden dimenzióban. Ha egy csomópontot szeretne felvenni a célrétegbe, amely megfelel a forrásréteg minden csomópontjának, adja hozzá a Padding = [true, true, true]; és módosítsa az RN1 méretét [5, 12, 12] értékre.

Megosztási deklaráció

A Net# opcionálisan támogatja több csomag közös súlyokkal való meghatározását. Bármelyik két csomag súlyát meg lehet osztani, ha a szerkezetük megegyezik. Az alábbi szintaxis a megosztott súlyokkal rendelkező csomagokat határozza meg:

share-declaration:
  share    {    layer-list    }
  share    {    bundle-list    }
  share    {    bias-list    }

  layer-list:
    layer-name    ,    layer-name
    layer-list    ,    layer-name

  bundle-list:
    bundle-spec    ,    bundle-spec
    bundle-list    ,    bundle-spec

  bundle-spec:
    layer-name    =>     layer-name

  bias-list:
    bias-spec    ,    bias-spec
    bias-list    ,    bias-spec

  bias-spec:
    1    =>    layer-name

  layer-name:
    identifier

A következő megosztási deklaráció például megadja a rétegneveket, ami azt jelzi, hogy a súlyokat és az torzításokat is meg kell osztani:

Const {
  InputSize = 37;
  HiddenSize = 50;
  }
input {
  Data1 [InputSize];
  Data2 [InputSize];
  }
hidden {
  H1 [HiddenSize] from Data1 all;
  H2 [HiddenSize] from Data2 all;
  }
output Result [2] {
  from H1 all;
  from H2 all;
  }
share { H1, H2 } // share both weights and biases

• A bemeneti funkciók két egyenlő méretű bemeneti rétegre vannak particionálva.
• A rejtett rétegek ezután magasabb szintű funkciókat számolnak ki a két bemeneti rétegen.
• A megosztási deklaráció azt határozza meg, hogy a H1 és a H2 számítása a saját bemenetüktől azonos módon történik.

Ezt két külön megosztási deklarációval is meg lehet adni az alábbiak szerint:

share { Data1 => H1, Data2 => H2 } // share weights
<!-- -->
    share { 1 => H1, 1 => H2 } // share biases

A rövid űrlapot csak akkor használhatja, ha a rétegek egyetlen köteget tartalmaznak. A megosztás általában csak akkor lehetséges, ha a megfelelő struktúra azonos, vagyis azonos méretűek, azonos konvolúciós geometriával és így tovább.

Példák a Net#-használatra

Ez a szakasz néhány példát mutat be arra, hogyan adhat hozzá rejtett rétegeket a Net# használatával, hogyan határozhatja meg a rejtett rétegek más rétegekkel való interakcióját, és hogyan hozhat létre konvolúciós hálózatokat.

Egyszerű egyéni neurális hálózat definiálása: "„Helló világ!” alkalmazás" példa

Ez az egyszerű példa bemutatja, hogyan hozható létre egyetlen rejtett réteggel rendelkező neurális hálózati modell.

input Data auto;
hidden H [200] from Data all;
output Out [10] sigmoid from H all;

A példa néhány alapvető parancsot az alábbiak szerint szemléltet:

• Az első sor határozza meg a bemeneti réteget (neve).Data A kulcsszó használatakor a auto neurális hálózat automatikusan tartalmazza a bemeneti példák összes funkcióoszlopát.
• A második sor létrehozza a rejtett réteget. A név H a rejtett réteghez van rendelve, amely 200 csomóponttal rendelkezik. Ez a réteg teljes mértékben csatlakozik a bemeneti réteghez.
• A harmadik sor határozza meg a kimeneti réteget (neve), Outamely 10 kimeneti csomópontot tartalmaz. Ha a neurális hálózatot a besoroláshoz használják, osztályonként egy kimeneti csomópont található. A kulcsszó sigmoid azt jelzi, hogy a kimeneti függvény a kimeneti rétegre lesz alkalmazva.

Több rejtett réteg definiálása: példa számítógépes látásra

Az alábbi példa bemutatja, hogyan definiálhat egy valamivel összetettebb neurális hálózatot több egyéni rejtett réteggel.

// Define the input layers
input Pixels [10, 20];
input MetaData [7];

// Define the first two hidden layers, using data only from the Pixels input
hidden ByRow [10, 12] from Pixels where (s,d) => s[0] == d[0];
hidden ByCol [5, 20] from Pixels where (s,d) => abs(s[1] - d[1]) <= 1;

// Define the third hidden layer, which uses as source the hidden layers ByRow and ByCol
hidden Gather [100]
{
from ByRow all;
from ByCol all;
}

// Define the output layer and its sources
output Result [10]
{
from Gather all;
from MetaData all;
}

Ez a példa a neurális hálózatok specifikációs nyelvének számos funkcióját szemlélteti:

• A struktúra két bemeneti réteget Pixels és MetaData.
• A Pixels réteg két kapcsolatcsomag forrásrétege, célrétegekkel ByRow és ByCol.
• A rétegek Gather és Result célrétegek több kapcsolatcsomagban.
• A kimeneti réteg Resultegy célréteg két kapcsolatcsomagban; az egyik a második szint rejtett rétege Gather célrétegként, a másik a bemeneti réteget MetaData célrétegként.
• A rejtett rétegek és ByRow ByCola szűrt kapcsolat meghatározása predikátumkifejezések használatával. Pontosabban az [x, y] időpontban lévő ByRow csomópont azokhoz a csomópontokhoz csatlakozik, amelyekben Pixels az első indexkoordináta megegyezik a csomópont első koordinátájával( x). Hasonlóképpen, az [x, y] helyen lévő ByCol csomópont azokhoz a csomópontokhoz csatlakozik, amelyekben Pixels a második indexkoordináta a csomópont második koordinátáján belül van, y.

Konvolúciós hálózat definiálása többosztályos besoroláshoz: számjegyfelismerési példa

A következő hálózat definíciója a számok felismerésére szolgál, és bemutatja a neurális hálózatok testreszabásának speciális technikáit.

input Image [29, 29];
hidden Conv1 [5, 13, 13] from Image convolve
  {
  InputShape  = [29, 29];
  KernelShape = [ 5,  5];
  Stride      = [ 2,  2];
  MapCount    = 5;
  }
hidden Conv2 [50, 5, 5]
from Conv1 convolve
  {
  InputShape  = [ 5, 13, 13];
  KernelShape = [ 1,  5,  5];
  Stride      = [ 1,  2,  2];
  Sharing     = [false, true, true];
  MapCount    = 10;
  }
hidden Hid3 [100] from Conv2 all;
output Digit [10] from Hid3 all;

• A struktúra egyetlen bemeneti réteggel rendelkezik. Image

• A kulcsszó convolve azt jelzi, hogy a rétegek neve Conv2 Conv1 konvolúciós rétegek. Ezen rétegdeklarációk mindegyikét a konvolúciós attribútumok listája követi.

• A háló egy harmadik rejtett réteggel rendelkezik, Hid3amely teljes mértékben kapcsolódik a második rejtett réteghez. Conv2

• A kimeneti réteg csak Digita harmadik rejtett réteghez van csatlakoztatva. Hid3 A kulcsszó all azt jelzi, hogy a kimeneti réteg teljes mértékben csatlakozik.Hid3

• A konvolúció aritása három: a csuplok InputShapehossza , KernelShapeés StrideSharing.

• A kernelenkénti súlyok száma .1 + KernelShape\[0] * KernelShape\[1] * KernelShape\[2] = 1 + 1 * 5 * 5 = 26 Vagy 26 * 50 = 1300.

• Az egyes rejtett rétegek csomópontjait az alábbiak szerint számíthatja ki:

  NodeCount\[0] = (5 - 1) / 1 + 1 = 5 NodeCount\[1] = (13 - 5) / 2 + 1 = 5 NodeCount\[2] = (13 - 5) / 2 + 1 = 5

• A csomópontok teljes száma a réteg deklarált dimenziósságával ([50, 5, 5]) számítható ki az alábbiak szerint: MapCount * NodeCount\[0] * NodeCount\[1] * NodeCount\[2] = 10 * 5 * 5 * 5

• Mivel Sharing[d] csak hamis, d == 0a kernelek száma .MapCount * NodeCount\[0] = 10 * 5 = 50

Köszönetnyilvánítás

A neurális hálózatok architektúrájának testreszabására szolgáló Net# nyelvet Shon Katzenberger (Architect, Machine Learning) és Alexey Kamenev (szoftvermérnök, Microsoft Research) fejlesztette ki a Microsoftnál. Belsőleg használják gépi tanulási projektekhez és alkalmazásokhoz, a képészleléstől a szövegelemzésig. További információ: Neurális netek a Machine Learning Studióban – Bevezetés a Net használatába#