Üdvözöljük az Applied Deep Learning sorozat 3. részében. Az 1. rész gyakorlati bevezetés volt a mesterséges neurális hálózatokba, amely mind az elméletet, mind az alkalmazást számos kódpéldával és vizualizációval lefedte. A 2. részben mély tanulást alkalmaztunk a valós adatkészletekre, lefedve a 3 leggyakrabban előforduló problémát esettanulmányként: bináris osztályozás, többosztályos osztályozás és regresszió.
most elkezdünk belemerülni a speciális mély tanulási architektúrákba, kezdve a legegyszerűbbekkel: Autoencoderekkel.
- Bevezetés
- architektúra
- megvalósítás
- Autoencoderek Denoizálása
- ritka Autoencoderek
- használati esetek
- következtetés
a cikk kódja itt elérhető Jupyter jegyzetfüzetként, nyugodtan töltse le és próbálja ki saját maga.
Bevezetés
az Autoencoderek a feedforward neurális hálózatok egy speciális típusa, ahol a bemenet megegyezik a kimenettel. Tömörítik a bemenetet egy alacsonyabb dimenziós kódba, majd rekonstruálják a kimenetet ebből az ábrázolásból. A kód a bemenet kompakt “összefoglalása” vagy “tömörítése”, más néven látens tér reprezentáció.
az autoencoder 3 komponensből áll: kódoló, kód és dekóder. A kódoló tömöríti a bemenetet és előállítja a kódot, majd a dekóder csak ezzel a kóddal rekonstruálja a bemenetet.
az autoencoder felépítéséhez 3 dologra van szükségünk: egy kódolási módszerre, dekódolási módszerre és egy veszteségfüggvényre, hogy összehasonlítsuk a kimenetet a célponttal. Ezeket a következő részben fogjuk megvizsgálni.
az Autoencoderek elsősorban dimenziócsökkentési (vagy tömörítési) algoritmusok, néhány fontos tulajdonsággal:
- Adatspecifikus: az Autoencoderek csak arra képesek, hogy értelmesen tömörítsék az adatokat, hasonlóan ahhoz, amire kiképezték őket. Mivel megtanulják az adott képzési adatokra jellemző funkciókat, különböznek a szokásos adattömörítési algoritmustól, mint például a gzip. Tehát nem várhatjuk el, hogy egy kézzel írt számjegyeken képzett autoencoder tömörítse a tájképeket.
- veszteséges: Az autoencoder kimenete nem lesz pontosan ugyanaz, mint a bemenet, szoros, de degradált ábrázolás lesz. Ha azt szeretnénk, veszteségmentes tömörítés ők nem az út.
- felügyelet nélkül: az autoencoder betanításához nem kell semmi különöset tennünk, csak dobjuk rá a nyers bemeneti adatokat. Az autoencodereket felügyelet nélküli tanulási technikának tekintik, mivel nincs szükségük kifejezett címkékre a képzéshez. De hogy pontosabbak legyünk, önfelügyelet alatt állnak, mert a képzési adatokból saját címkéket generálnak.
architektúra
vizsgáljuk meg a kódoló, a kód és a dekóder részleteit. Mind a kódoló, mind a dekóder teljesen összekapcsolt feedforward neurális hálózatok, lényegében az 1.részben ismertetett Ann-ek. A kód az ANN egyetlen rétege, a választott dimenzióval. A kódrétegben lévő csomópontok száma (kódméret) egy hiperparaméter, amelyet az autoencoder betanítása előtt állítottunk be.
ez egy autoencoder részletesebb megjelenítése. Először a bemenet áthalad a kódolón, amely egy teljesen csatlakoztatott ANN, hogy előállítsa a kódot. A dekóder, amelynek hasonló ANN szerkezete van, akkor a kimenetet csak a kód segítségével állítja elő. A cél az, hogy a bemenettel azonos kimenetet kapjunk. Vegye figyelembe, hogy a dekóder architektúrája a kódoló tükörképe. Ez nem követelmény, de általában ez a helyzet. Az egyetlen követelmény, hogy a bemenet és a kimenet mérete azonos legyen. Bármi a közepén lehet játszani.
4 hiperparamétert kell beállítanunk az autoencoder betanítása előtt:
- kódméret: a középső réteg csomópontjainak száma. A kisebb méret nagyobb tömörítést eredményez.
- rétegek száma: az autoencoder olyan mély lehet, amennyit csak akarunk. A fenti ábrán 2 réteg van mind a kódolóban, mind a dekóderben, anélkül, hogy figyelembe vennénk a bemenetet és a kimenetet.
- csomópontok száma rétegenként: az autoencoder architektúrát, amin dolgozunk, stacked autoencodernek nevezzük, mivel a rétegek egymás után vannak egymásra rakva. Általában a halmozott autoencoderek úgy néznek ki, mint egy”szendvics”. A rétegenkénti csomópontok száma a kódoló minden egyes következő rétegével csökken,majd a dekóderben növekszik. A dekóder szintén szimmetrikus a kódolóval a rétegszerkezet szempontjából. Mint fentebb megjegyeztük, ez nem szükséges, és teljes ellenőrzésünk alatt tartjuk ezeket a paramétereket.
- Veszteségfüggvény: vagy a mean squared error (MSE) vagy a binary crossentropy funkciót használjuk. Ha a bemeneti értékek a tartományban vannak, akkor általában a crossentropy-t használjuk, különben az átlagos négyzethibát használjuk. További részletekért nézd meg ezt a videót.
az Autoencodereket ugyanúgy képzik, mint az ANNs-t a backpropagation segítségével. Nézze meg az 1. rész bevezetését a neurális hálózatok képzésével kapcsolatos további részletekért, ez közvetlenül vonatkozik az autoencoderekre.
implementáció
most hajtsunk végre egy autoencodert a következő architektúrához, 1 rejtett réteg a kódolóban és a dekóderben.
a rendkívül népszerű MNIST adatkészletet fogjuk használni bemenetként. Fekete-fehér képeket tartalmaz kézzel írt számjegyekről.
28×28 méretűek, és 784-es számok vektoraként használjuk őket . Ellenőrizze a jupyter notebook a részleteket.
most az autoencodert keras-szal valósítjuk meg. A hiperparaméterek: 128 csomópont a rejtett rétegben, a kódméret 32, a bináris kereszttrópia pedig a veszteségfüggvény.
ez nagyon hasonlít az ANNs-hez, amelyen dolgoztunk, de most a Keras funkcionális API-t használjuk. A részletekért olvassa el ezt az útmutatót, de itt van egy gyors összehasonlítás. Mielőtt rétegeket adtunk volna hozzá a szekvenciális API használatával az alábbiak szerint:
model.add(Dense(16, activation='relu'))
model.add(Dense(8, activation='relu'))
a funkcionális API – val ezt tesszük:
layer_1 = Dense(16, activation='relu')(input)
layer_2 = Dense(8, activation='relu')(layer_1)
bőbeszédűbb, de rugalmasabb módszer a komplex modellek meghatározására. Könnyen megragadhatjuk a modellünk egyes részeit, például csak a dekódert, és ezzel dolgozhatunk. A sűrű módszer kimenete egy hívható réteg, a funkcionális API segítségével biztosítjuk a bemenetet és tároljuk a kimenetet. A réteg kimenete a következő réteg bemenetévé válik. A szekvenciális API-val az add módszer implicit módon kezelte ezt számunkra.
vegye figyelembe, hogy az összes réteg a relu aktiválási funkciót használja, mivel ez a mély neurális hálózatok szabványa. Az utolsó réteg a szigmoid aktiválást használja, mert szükségünk van a kimenetekre . A bemenet szintén ugyanabban a tartományban van.
vegye figyelembe a Call to fit funkciót is, mielőtt az ANNs-szel szoktuk csinálni:
model.fit(x_train, y_train)
de most már:
model.fit(x_train, x_train)
ne feledje, hogy az autoencoder célpontjai megegyeznek a bemenettel. Ezért adjuk meg a képzési adatokat célként.
vizualizáció
most vizualizáljuk, hogy az autoencoder milyen jól rekonstruálja a bemenetét.
az autoencodert a tesztkészleten egyszerűen a keras predict függvényével futtatjuk. A tesztkészlet minden képéhez megkapjuk az autoencoder kimenetét. Arra számítunk, hogy a kimenet nagyon hasonló lesz a bemenethez.
valóban nagyon hasonlóak, de nem pontosan ugyanaz. Egyértelműbben észrevehetjük az utolsó “4”számjegyben. Mivel ez egy egyszerű feladat volt, az autoencoder elég jól teljesített.
Tanács
teljes ellenőrzésünk van az autoencoder architektúrája felett. Nagyon erőssé tehetjük, ha növeljük a rétegek számát, A rétegenkénti csomópontokat és ami a legfontosabb, a kód méretét. Ezeknek a hiperparamétereknek a növelése lehetővé teszi az autoencoder számára, hogy összetettebb kódolásokat tanuljon meg. De vigyáznunk kell, hogy ne tegyük túl erőssé. Ellenkező esetben az autoencoder egyszerűen megtanulja lemásolni a bemeneteit a kimenetre, anélkül, hogy megtanulna bármilyen értelmes ábrázolást. Csak utánozza az identitás funkciót. Az autoencoder tökéletesen rekonstruálja az edzési adatokat, de túltöltődik anélkül, hogy képes lenne általánosítani az új példányokra, ami nem az, amit akarunk.
ezért részesítjük előnyben a “sandwitch” architektúrát, és szándékosan tartjuk kicsinek a kódméretet. Mivel a kódolási réteg kisebb dimenzióval rendelkezik, mint a bemeneti adatok, az autoencoderről azt mondják, hogy nem teljes. Nem lesz képes közvetlenül lemásolni a bemeneteit a kimenetre, és kénytelen lesz megtanulni az intelligens funkciókat. Ha a bemeneti adatoknak mintázata van, például az “1” szám általában kissé egyenes vonalat tartalmaz, a “0” szám pedig kör alakú, megtanulja ezt a tényt, és kompaktabb formában kódolja. Ha a bemeneti adatok teljesen véletlenszerűek voltak, belső korreláció vagy függőség nélkül, akkor az alulteljesített autoencoder nem lesz képes tökéletesen helyreállítani. De szerencsére a való világban sok a függőség.
az Autoencoderek eltávolítása
a kódréteg kicsinek tartása arra kényszerítette autoencoderünket, hogy megtanulja az adatok intelligens ábrázolását. Van egy másik módja annak, hogy az autoencodert hasznos funkciók megtanulására kényszerítsük, ami véletlenszerű zajt ad a bemeneteihez, és így visszaállítja az eredeti zajmentes adatokat. Így az autoencoder nem tudja egyszerűen átmásolni a bemenetet a kimenetére, mert a bemenet véletlenszerű zajt is tartalmaz. Arra kérjük, hogy vonja le a zajt, és hozza létre az alapul szolgáló értelmes adatokat. Ez az úgynevezett denoising autoencoder.
a felső sor tartalmazza az eredeti képeket. Véletlenszerű Gauss-zajt adunk hozzájuk, és a zajos adatok az autoencoder bemenetévé válnak. Az autoencoder egyáltalán nem látja az eredeti képet. De akkor azt várjuk, hogy az autoencoder regenerálja a zajmentes eredeti képet.
csak egy kis különbség van a denoising autoencoder implementációja és a normál között. Az architektúra egyáltalán nem változik, csak az illesztési funkció. A szokásos autoencodert a következőképpen képeztük ki:
autoencoder.fit(x_train, x_train)
a Denoising autoencoder úgy van kiképezve, mint:
autoencoder.fit(x_train_noisy, x_train)
ilyen egyszerű, minden más pontosan ugyanaz. Az autoencoder bemenete a zajos kép,a várt cél pedig az eredeti zajmentes.
vizualizáció
most vizualizáljuk, hogy képesek vagyunk-e helyreállítani a zajmentes képeket.
elég jól néz ki. Az alsó sor az autoencoder kimenet. Jobban teljesíthetünk bonyolultabb autoencoder architektúra használatával,mint például a konvolúciós autoencoderek. A következő cikkben kitérünk a konvolúciókra.
ritka Autoencoderek
két módszert mutattunk be arra, hogy az autoencodert hasznos funkciók megtanulására kényszerítsük: a kódméret kicsi tartása és az autoencoderek denoizálása. A harmadik módszer a szabályozás alkalmazása. Szabályozhatjuk az autoencoder-t egy olyan ritka kényszer használatával, hogy a csomópontoknak csak egy töredéke legyen nem nulla érték, az úgynevezett aktív csomópontok.
különösen olyan büntetési kifejezést adunk a veszteségfüggvényhez, hogy a csomópontoknak csak egy töredéke válik aktívvá. Ez arra kényszeríti az autoencodert, hogy minden bemenetet kis számú csomópont kombinációjaként jelenítsen meg, és megköveteli, hogy érdekes struktúrát fedezzen fel az adatokban. Ez a módszer akkor is működik, ha a kód mérete nagy, mivel a csomópontoknak csak egy kis részhalmaza lesz aktív bármikor.
ez elég egyszerű, hogy ezt a Keras csak egy paraméter. Emlékeztetőül, korábban a következőképpen hoztuk létre a kódréteget:
code = Dense(code_size, activation='relu')(input_img)
most hozzáadunk egy másik paramétert, az activity_regularizer nevű paramétert a szabályozási erő megadásával. Ez általában egy érték a tartományban . Itt a 10e-6-ot választottuk.
code = Dense(code_size, activation='relu', activity_regularizer=l1(10e-6))(input_img)
a ritka modell végső vesztesége 0,01-rel magasabb, mint a standard, a hozzáadott szabályozási kifejezés miatt.
mutassuk be, hogy a regularizált modell által generált kódolások valóban ritkák. Ha megnézzük a tesztkészletben lévő képek kódértékeinek hisztogramját, az eloszlás a következő:
a standard modell átlaga 6,6, de a regularizált modell esetében 0,8, ami elég nagy csökkenés. Láthatjuk, hogy a regularizált modellben a kódértékek nagy része valóban 0, amit akartunk. A regularizált modell varianciája szintén meglehetősen alacsony.
használati esetek
most a következő kérdéseket tehetjük fel. Mennyire jók az autoencoderek a bemenet tömörítésében? Általánosan használt deep learning technika?
sajnos az autoencodereket nem használják széles körben a valós alkalmazásokban. Tömörítési módszerként nem teljesítenek jobban, mint az alternatívái, például a jpeg jobban tömöríti a fényképeket, mint egy autoencoder. Az a tény, hogy az autoencoderek adatspecifikusak, általános technikaként nem praktikusak. Nekik van 3 gyakori használati esetek mégis:
- adatok denoising: láttunk erre példát a képeken.
- Dimenziócsökkentés: a nagy dimenziós adatok vizualizálása kihívást jelent. a t-SNE a leggyakrabban használt módszer, de nagyszámú dimenzióval küzd (általában 32 felett). Tehát az autoencodereket előfeldolgozási lépésként használják a dimenzió csökkentése érdekében, és ezt a tömörített ábrázolást a t-SNE használja az adatok 2D térben történő megjelenítésére. A t-SNE-ről szóló nagyszerű cikkeket itt és itt találja.
- variációs Autoencoderek (VAE): ez az autoencoderek modernebb és összetettebb felhasználási esete, és egy másik cikkben foglalkozunk velük. De gyors összefoglalásként a VAE megtanulja a bemeneti adatok modellezésének valószínűségi eloszlásának paramétereit, ahelyett, hogy a vanília autoencoderek esetében tetszőleges függvényt tanulna. Ebből az eloszlásból származó mintavételi pontokkal a VAE-t generatív modellként is felhasználhatjuk. Itt van egy jó referencia.
következtetés
az Autoencoderek nagyon hasznos dimenziócsökkentő technika. Nagyon népszerűek tananyagként a bevezető mély tanulási tanfolyamokon, valószínűleg egyszerűségük miatt. Ebben a cikkben részletesen foglalkoztunk velük, és remélem, hogy tetszett.
a cikk teljes kódja itt érhető el, ha saját maga akarja feltörni. Ha bármilyen visszajelzése van, nyugodtan forduljon hozzám a Twitteren.