Végső útmutató a visszatérő neurális hálózatokhoz a Pythonban

A visszatérő neurális hálózatok olyan mély tanulási modellek, amelyeket tipikusan idősoros problémák megoldására használnak. Használják önvezető autókban, nagyfrekvenciás kereskedési algoritmusokban és más valós alkalmazásokban.

Ez a bemutató megtanítja a visszatérő ideghálózatok alapjait. Felépít egy saját visszatérő ideghálózatot, amely megjósolja a Facebook (FB) holnapi árfolyamát.

A visszatérő ideghálózatok intuíciója

A visszatérő ideghálózatok a példa az ideghálózatok szélesebb körére. További példák:

  • Mesterséges idegi hálózat
  • Konvolúciós ideghálózatok

Ez a cikk a visszatérő ideghálózatokra összpontosít.

Ez a bemutató a visszatérő ideghálózatokról szóló beszélgetésünket a visszatérő ideghálózatok mögött rejlő intuíció megvitatásával kezdi.

A visszatérő ideghálózatok által megoldott problémák típusai

Bár még nem beszéltünk róla kifejezetten, általában sokféle probléma létezik, amelyek megoldására az egyes ideghálózatok típusait tervezik:

  • Mesterséges ideghálózatok: osztályozási és regressziós problémák
  • Konvolúciós neurális hálózatok: számítógépes látási problémák

A visszatérő ideghálózatok esetében jellemzően idősor-elemzési problémák megoldására szolgálnak.

A neurális hálózatok mindhárom típusát (mesterséges, konvolúciós és visszatérő) felügyelt gépi tanulási problémák megoldására használják.

A neurális hálózatok feltérképezése az emberi agy részeire

Mint emlékszel, a neurális hálózatokat úgy tervezték, hogy utánozzák az emberi agyat. Ez mind konstrukciójukra (mind az agy, mind az ideghálózatok idegsejtekből állnak) és a funkciójukra (mindkettőt felhasználják döntések meghozatalára és jóslatokra).

Az agy három fő része:

  • A kisagy
  • Az agytörzs
  • A kisagy

Az agy vitathatatlanul legfontosabb része a kisagy. Négy lebenyt tartalmaz:

  • A homloklebeny
  • A parietális lebeny
  • Az időbeli lebeny
  • Az occipitális lebeny

A neurális hálózatok legfőbb újítása a súlyok gondolata.

Másképp mondva, az agy legfontosabb jellemzője, amelyet az ideghálózatok utánoztak, az a képesség, hogy más idegsejtektől tanuljon.

Az ideghálózat képessége a súlyának megváltoztatására edzési szakaszának minden korszakában hasonló ahhoz a hosszú távú memóriához, amely az embereknél (és más állatoknál) látható.

A temporális lebeny az agy azon része, amely a hosszú távú memóriához kapcsolódik. Külön-külön, a mesterséges neurális hálózat volt az első típusú neurális hálózat, amely rendelkezik ezzel a hosszú távú memória tulajdonsággal. Ebben az értelemben sok kutató összehasonlította a mesterséges ideghálózatokat az emberi agy temporális lebenyével.

Hasonlóképpen, az occipitális lebeny az agy azon része, amely látásunkat hajtja. Mivel a konvolúciós ideghálózatokat tipikusan számítógépes látásproblémák megoldására használják, mondhatnánk, hogy ekvivalensek az agy nyakszirtével.

Mint említettük, visszatérő ideghálózatokat használnak az idősoros problémák megoldására. Tanulhatnak olyan eseményekből, amelyek az edzésszakasz legutóbbi előző iterációiban történtek. Ily módon gyakran összehasonlítják őket az agy homloklebenyével - amely a rövid távú memóriánkat működteti.

Összefoglalva, a kutatók a három idegháló mindegyikét gyakran párosítják az agy következő részeivel:

  • Mesterséges ideghálózatok: a temporális lebeny
  • Konvolúciós ideghálózatok: az occipitális lebeny
  • Visszatérő ideghálózatok: a frontális lebeny

A visszatérő idegháló összetétele

Beszéljünk most egy visszatérő idegháló összetételéről. Először is emlékeztessen arra, hogy az alapvető ideghálózat összetétele a következő megjelenésű:

Alap idegi hálózat

Az első módosítás, amelyet ebben a neurális hálózatban el kell végezni, az, hogy a hálózat minden rétegét össze kell összezúzni, így:

Összeszorult ideghálózat

Ezután még három módosítást kell végrehajtani:

  • Az ideghálózat idegsejt szinapszisait egyetlen vonallá kell egyszerűsíteni
  • A teljes ideghálózatot 90 fokkal el kell forgatni
  • Hurkot kell létrehozni az idegháló rejtett rétege körül

Az ideghálózat most a következő megjelenésű lesz:

Visszatérő idegháló

Ezt a vonalat, amely a visszatérő ideghálózat rejtett rétegét körözi, időbeli huroknak hívjuk. Azt jelzik, hogy a rejtett réteg nem csak kimenetet generál, hanem a kimenetet is visszajuttatja bemenetként ugyanabba a rétegbe.

A vizualizáció hasznos ennek megértésében. Amint a következő képen láthatja, az adatkészlet meghatározott megfigyelésénél használt rejtett réteget nem csak az adott megfigyelés kimenetének előállítására használják, hanem a következő megfigyelés rejtett rétegének kiképzésére is.

Idősor visszatérő ideghálózat

Az egyik megfigyelésnek ez a tulajdonsága segíti a következő megfigyelés kiképzését, ezért a visszatérő ideghálózatok olyan hasznosak az idősor-elemzési problémák megoldásában.

Összegzés - A visszatérő ideghálózatok intuíciója

Ebben az oktatóanyagban először ismertette a visszatérő ideghálózatokat. Pontosabban a visszatérő ideghálózatok mögött rejlő intuícióról beszélgettünk.

Itt van egy rövid összefoglaló arról, amit ebben az oktatóanyagban tárgyaltunk:

  • A visszatérő ideghálózatok által megoldott problémák típusai
  • Az agy különböző részei és a különböző ideghálózatok közötti kapcsolatok, amelyeket ezen a tanfolyamon tanulmányoztunk
  • A visszatérő idegháló összetétele és az egyes rejtett rétegek felhasználása a rejtett réteg kiképzéséhez az adatkészlet következő megfigyeléséből

Az eltűnő gradiens probléma a visszatérő ideghálózatokban

Az eltűnő gradiens probléma történelmileg a visszatérő ideghálózatok sikerének egyik legnagyobb akadálya volt.

Emiatt az első RNN felépítése előtt fontos, hogy megértsük az eltűnő gradiens problémát.

Ez a szakasz egyszerű angol nyelven magyarázza el az eltűnő gradiens problémát, beleértve az érdekes probléma leghasznosabb megoldásait is.

Mi az eltűnő gradiens probléma?

Mielőtt belemerülnénk az eltűnő gradiensprobléma részleteibe, hasznos, ha megértjük, hogyan fedezték fel a problémát eredetileg.

Az eltűnő gradiens problémát Sepp Hochreiter, egy német informatikus fedezte fel, akinek befolyásos szerepe volt a mély tanulásban visszatérő ideghálózatok kialakításában.

Most vizsgáljuk meg részletesen az eltűnő gradiens problémát. Ahogy a neve is mutatja, az eltűnő gradiens probléma összefügg a mély tanulási gradiens süllyedés algoritmusokkal. Emlékezzünk arra, hogy a gradiens ereszkedési algoritmus a következőképpen néz ki:

Véglegesített gradiens süllyedési algoritmus

Ezt a gradiens süllyedési algoritmust ezután egy backpropation algoritmussal kombinálják, hogy frissítsék a szinapszisúlyokat az egész ideghálózatban.

A visszatérő ideghálózatok kissé eltérően viselkednek, mert az egyik megfigyelés rejtett rétegét használják a következő megfigyelés rejtett rétegének kiképzésére.

Ismétlődő neurális hálózat gradiens süllyedési algoritmus

Ez azt jelenti, hogy az idegháló költségfüggvényét kiszámítják az adatkészlet minden megfigyelésére. Ezeket a költségfüggvény értékeket a következő kép tetején mutatjuk be:

Ismétlődő neurális hálózat gradiens süllyedési algoritmus

Az eltűnő gradiens probléma akkor fordul elő, amikor a backpropagation algoritmus visszahúzódik az idegháló összes neuronján, hogy frissítse súlyát. A visszatérő ideghálózatok jellege azt jelenti, hogy az idegháló mélyrétegén kiszámított költségfüggvényt a sekélyebb rétegekben található idegsejtek súlyának megváltoztatására használják.

A változást kiszámító matematika multiplikatív, ami azt jelenti, hogy az ideghálózat mélyén lévő lépésben kiszámított gradiens vissza fog szorozni a hálózat korábbi súlyaival. Másképp mondva, a hálózat mélyén kiszámított gradiens "hígul", amikor a hálón keresztül visszafelé mozog, ami a gradiens eltűnését okozhatja - adva a nevet az eltűnő gradiens problémának!

A tényleges tényezőre, amelyet a backpropagation algoritmusban visszatérő ideghálón keresztül megszoroznak, a matematikai változó utal Wrec. Két problémát vet fel:

  • Ha Wreckicsi, akkor eltűnő gradiens problémát tapasztal
  • Ha Wrecnagy, akkor robbanó színátmenet problémát tapasztal

Ne feledje, hogy ezekre a problémákra általában az „eltűnő gradiens probléma” egyszerűbb neve utal.

Összefoglalva, az eltűnő gradiens problémát a backpropagation algoritmus multiplikatív jellege okozza. Ez azt jelenti, hogy a visszatérő ideghálózat mély szakaszában számított gradienseknek vagy túl kicsi a hatásuk (eltűnő gradiensprobléma esetén), vagy túl nagy a hatásuk (robbanó gradiensproblémában) az alacsonyabb neuronok tömegére. az idegháló.

Hogyan lehet megoldani az eltűnő gradiens problémát

Számos stratégia alkalmazható az eltűnő gradiens probléma megoldására. Külön megvizsgáljuk az eltűnő gradiens és a felrobbanó gradiens problémák stratégiáit. Kezdjük az utóbbival.

A robbanó színátmenet probléma megoldása

Robbanó gradiensek esetén lehetőség van a backpropagation algoritmus módosított változatának használatára truncated backpropagation. A csonka backpropagation algoritmus korlátozza az időutazások számát, amelyeken a backproporáció végrehajtásra kerül, és megállítja az algoritmust, mielőtt a robbanó gradiens probléma jelentkezne.

penaltiesBemutathat olyanokat is , amelyek kemény kódolású technikák csökkentik a háttérpropagáció hatását, amikor az ideghálózat sekélyebb rétegein mozog.

Végül gradient clippingbevezethet egy mesterséges plafont, amely korlátozza, hogy a gradiens mekkora lehet egy backpropagation algoritmusban.

Az eltűnő gradiens probléma megoldása

A súly inicializálása az egyik technika, amely felhasználható az eltűnő gradiens probléma megoldására. Ez magában foglalja a kezdeti érték mesterséges létrehozását a súlyok számára egy neurális hálózatban, hogy megakadályozza a backpropagation algoritmus irreálisan kicsi súlyok kiosztását.

Használhat echo állapotú hálózatokat is, amelyek egy meghatározott típusú ideghálózatok, amelyek célja az eltűnő gradiens probléma elkerülése. Az echo állapotú hálózatok nem tartoznak a tanfolyam körébe. Egyelőre elegendő a létezésük ismerete.

Az eltűnő gradiensprobléma legfontosabb megoldása a Long Short-Term Memory Networks (LSTM) nevű speciális neurális hálózat, amelynek úttörői Sepp Hochreiter és Jürgen Schmidhuber voltak. Emlékezzünk vissza, hogy Mr. Hochreiter volt az a tudós, aki eredetileg felfedezte az eltűnő gradiens problémát.

Az LSTM-eket elsősorban a beszédfelismeréssel kapcsolatos problémákban használják, az egyik legemlékezetesebb példa az, hogy a Google 2015-ben LSTM-t használt beszédfelismeréshez, és 49% -kal csökkent az átírási hibák száma.

Az LSTM-eket a visszatérő ideghálózatok megvalósításában érdekelt tudósok go-to neurális hálójának tekintik. A tanfolyam hátralévő részében nagyrészt az LSTM-ekre fogunk koncentrálni.

Összegzés - Az eltűnő gradiens probléma

Ebben a szakaszban megismerkedett a visszatérő ideghálózatok eltűnő gradiens problémájával.

Itt van egy rövid összefoglaló arról, amit megbeszéltünk:

  • Hogy Sepp Hochreiter volt az első tudós, aki felfedezte az eltűnő gradiens problémát a visszatérő idegi hálózatokban
  • Mit jelent az eltűnő gradiensprobléma (és unokatestvére, a robbanó gradiensprobléma)
  • A Wrecgradiens problémák eltűnésének és a gradiens problémák felrobbanásának szerepe
  • Hogyan oldhatók meg az eltűnő gradiens problémák és a robbanó gradiens problémák
  • Az LSTM-ek szerepe, mint az eltűnő gradiens probléma leggyakoribb megoldása

Hosszú távú memória hálózatok (LSTM)

A hosszú rövid távú memóriahálózatok (LSTM) egyfajta visszatérő ideghálózat, amelyet az eltűnő gradiens probléma megoldására használnak.

Fontos szempontból különböznek a „szabályos” visszatérő ideghálótól.

Ez az oktatóanyag bemutatja az LSTM-eket. Ezen a tanfolyamon később egy nulláról építünk és képzünk egy LSTM-et.

Tartalomjegyzék

Az alábbi tartalomjegyzék használatával ugorhat az LSTM oktatóanyag egy adott szakaszára:

  • Az LSTM-ek története
  • Hogyan oldják meg az LSTM-ek az eltűnő gradiens problémát
  • Hogyan működnek az LSTM-ek
  • Az LSTM architektúrák variációi
  • A kukucskáló variáció
  • A kapcsolt kapu variáció
  • Egyéb LSTM variációk
  • Végső gondolatok

Az LSTM-ek története

Ahogy az utolsó részben utaltunk rá, az LSTM-ek terén a két legfontosabb figura Sepp Hochreiter és Jürgen Schmidhuber.

Utóbbi előbbi PhD témavezetője volt a németországi Müncheni Műszaki Egyetemen.

Hochreiter doktori disszertációja először mutatta be az LSTM-eket a világnak.

Hogyan oldják meg az LSTM-ek az eltűnő gradiens problémát

Az utolsó oktatóanyagban megtudtuk, hogy a Wrecbackpropagation algoritmusban szereplő kifejezés hogyan vezethet eltűnő gradiens problémához vagy robbanó gradiens problémához.

Megvizsgáltuk a probléma különféle lehetséges megoldásait, beleértve a büntetéseket, a gradiens vágást és még az államhálókat is. Az LSTM-ek a legjobb megoldás.

Tehát hogyan működnek az LSTM-ek? Egyszerűen megváltoztatják a Wrec.

Az eltűnő gradiens probléma magyarázatában megtudta, hogy:

  • Ha Wreckicsi, akkor eltűnő gradiens problémát tapasztal
  • Ha Wrecnagy, akkor robbanó színátmenet problémát tapasztal

Valójában sokkal konkrétabbak lehetünk:

  • Amikor Wrec < 1egy eltűnő gradiens problémát tapasztal
  • Mikor Wrec > 1robbanó gradiens problémát tapasztal

Ennek akkor van értelme, ha belegondol a backpropagation algoritmus multiplikatív jellegébe.

Ha van egy számod, amely kisebb, mint, 1és újra és újra megsokszorozod önmagaddal, akkor egy szám eltűnik. Hasonlóképpen, ha egy önmagánál nagyobb számot 1sokszor megszorozunk, nagyon nagy számot kapunk.

A probléma megoldása érdekében az LSTM-ek beállítottak Wrec = 1. Az LSTMS minden bizonnyal többet tartalmaz, mint a beállítás Wrec = 1, de ez egyértelműen a legfontosabb változás, amelyet a visszatérő ideghálózatok ezen specifikációja végrehajt.

Hogyan működnek az LSTM-ek

Ez a szakasz elmagyarázza az LSTM-ek működését. A folytatás előtt érdemes megemlíteni, hogy Christopher Olah Understanding LSTMs című blogbejegyzéséből származó képeket fogom felhasználni, amely 2015 augusztusában jelent meg, és a legjobb LSTM vizualizációkkal rendelkezik, amelyeket valaha láttam.

Kezdésként vegyük figyelembe a visszatérő ideghálózat alapvető verzióját:

Alapvető visszatérő ideghálózat

Ennek az ideghálózatnak vannak olyan neuronjai és szinapszisei, amelyek az egyik réteg kimeneteinek súlyozott összegét továbbítják a következő réteg bemeneteként. A backpropagation algoritmus visszafelé halad ezen az algoritmuson keresztül, és frissíti az egyes idegsejtek súlyát, válaszul a képzési szakasz minden korszakában kiszámított költségfüggvényre.

Ezzel szemben egy LSTM így néz ki:

Egy LSTM

Amint láthatja, az LSTM sokkal nagyobb beágyazottsággal rendelkezik, mint egy rendszeres visszatérő ideghálózat. Célom, hogy lehetővé tegyem Önnek, hogy teljesen megértse ezt a képet, mire befejezi ezt az oktatást.

Először érezzük jól magunkat a fenti képen használt jelöléssel:

Az LSTM oktatóanyagunkban használt jelölés

Most, hogy megérti a jelölést, amelyet ebben az LSTM oktatóanyagban használunk, elkezdhetjük megvizsgálni egy réteg funkcionalitását az LSTM neurális hálón belül. Minden réteg megjelenése a következő:

Csomópont egy LSTM neurális hálózatból

Mielőtt elmélyülnénk a csomópontok funkcionalitásában az LSTM neurális hálózaton belül, érdemes megjegyezni, hogy ezeknek a mély tanulási modelleknek minden bemenete és kimenete vektor. A Pythonban ezt általában NumPy tömb vagy más egydimenziós adatszerkezet képviseli.

Az első dolog, ami egy LSTM-en belül történik, az a forget gate layer. Úgy néz ki, hogy a bemeneti réteg (jelölt xtmegfigyelésére és hta termelés a korábbi réteg a neurális hálózat) és kimenetek vagy 1, vagy 0minden számot a sejtállapotra az előző réteg (jelölt Ct-1).

Az alábbiakban bemutatjuk a következő aktiválását forget gate layer:

Csomópont egy LSTM neurális hálózatból

A sejtállapotról még nem beszéltünk, ezért tegyük ezt most. A sejt állapotát diagramunkon a diagram tetején átfutó hosszú vízszintes vonal képviseli. Például itt van a cellák állapota a vizualizációinkban:

Cellaállapot az LSTM hálózatokon belül

A sejtállapot célja annak eldöntése, hogy milyen információkat vigyen tovább a különböző megfigyelésekből, amelyeken a visszatérő ideghálózat képzett. A döntés arról, hogy továbbítja-e az információt, vagy sem, gatesamelyre forget gateez a példa. Az LSTM minden kapuja a következő megjelenésű lesz:

Cellaállapot az LSTM hálózatokon belül

Az σezeken a kapukon lévő karakter a Sigmoid függvényre utal, amelyet valószínűleg a logisztikai regressziós gépi tanulási modellekben használtak. A sigmoid függvényt az LSTM-ek egyik aktiválási funkciójának típusaként használják, amely meghatározza, hogy egy kapun keresztül milyen információk kerülnek át a hálózat sejtállapotának befolyásolására.

Definíció szerint a Sigmoid függvény csak 0és között számokat adhat ki 1. Gyakran használják emiatt a valószínűségek kiszámításához. Az LSTM modellek esetében meghatározza, hogy az egyes kimenetek mekkora hányadát szabad befolyásolni az eladási állapotban.

Az LSTM modell következő két lépése szorosan kapcsolódik egymáshoz: a input gate layerés a tanh layer. Ezek a rétegek együttműködve határozzák meg, hogyan frissítsék a sejt állapotát. Ezzel egy időben befejeződik az utolsó lépés, amely lehetővé teszi a cella számára, hogy meghatározza, mit felejtsen el az adatsor utolsó megfigyeléséről.

Itt látható ennek a folyamatnak a képe:

Csomópont egy LSTM neurális hálózatból

Az LSTM utolsó lépése határozza meg ennek a megfigyelésnek a kimenetét (jelölve ht). Ez a lépés mind a sigmoid, mind a hiperbolikus tangens függvényen keresztül fut. Az alábbiak szerint vizualizálható:

Csomópont egy LSTM neurális hálózatból

Ezzel lezárul az LSTM modell egyetlen rétegének kiképzése. Ahogy elképzelheted, rengeteg matematika van a felszín alatt, amelyet átvilágítottunk. Ennek a szakasznak az a célja, hogy tágan elmagyarázza az LSTM-ek működését, és nem azért, hogy mélyen megértse a folyamat egyes műveleteit.

Az LSTM architektúrák variációi

Ezt az oktatóanyagot az LSTM architektúra néhány különféle változatának megvitatásával akartam befejezni, amelyek kissé eltérnek az eddig tárgyalt alapvető LSTM-től.

Gyors összefoglalásként a következőképpen néz ki az LSTM általánosított csomópontja:

Csomópont egy LSTM neurális hálózatból

A kukucskáló variáció

Az LSTM architektúra talán legfontosabb változata az a peepholeváltozat, amely lehetővé teszi a kapurétegek számára , hogy adatokat olvassanak a sejt állapotából.

Itt látható a kukucskáló változat változata:

Csomópont egy kukucskáló LSTM neurális hálózatból

Vegye figyelembe, hogy bár ez a diagram egy kukucskálót ad a visszatérő ideghálózat minden kapujához, egyes kapukhoz hozzáadhat kukucskáló lyukakat is, más kapukhoz nem.

A kapcsolt kapu variáció

Az LSTM architektúrának van egy másik változata, ahol a modell eldönti, hogy mit felejtsen el és mihez adjon hozzá új információt. Az eredeti LSTM modellben ezeket a döntéseket külön hozták meg.

Itt látható egy kép, hogyan néz ki ez az architektúra:

Csomópont egy kapcsolt kapu LSTM neurális hálózatból

Egyéb LSTM variációk

Ez csak két példa az LSTM architektúra variánsaira. Sokkal többen vannak. Az alábbiakban felsorolunk néhányat:

  • Kapuzatos visszatérő egységek (GRU)
  • Mélység Kapu RNN
  • Óramű RNN-ek

Összegzés - hosszú rövid távú memóriahálózatok

Ebben az oktatóanyagban először találkozott hosszú távú memóriahálózatokkal (LSTM).

Itt van egy rövid összefoglaló a tanultakról:

  • Az LSTM-ek (nagyon) rövid története és Sepp Hochreiter és Jürgen Schmidhuber szerepe a fejlődésükben
  • Hogyan oldják meg az LSTM-ek az eltűnő gradiens problémát
  • Hogyan működnek az LSTM-ek
  • A kapuk, a szigmoid függvények és a hiperbolikus tangens funkció szerepe az LSTM-ekben
  • Az LSTM architektúra néhány legnépszerűbb változata

Hogyan lehet kiépíteni és kiképezni egy visszatérő ideghálózatot

A visszatérő ideghálózatokról folytatott beszélgetésünk során eddig megtanultad:

  • A visszatérő ideghálózatok mögött álló alapvető megérzés
  • Az eltűnő gradiens probléma, amely történelmileg akadályozta a visszatérő ideghálózatok fejlődését
  • Mennyire segítenek a rövid távú memória hálózatok (LSTM) megoldani az eltűnő gradiens problémát

Itt az ideje, hogy kiépítse első visszatérő ideghálóját! Pontosabban, ez az oktatóanyag megtanítja Önt, hogyan kell felépíteni és kiképezni egy LSTM-et a Facebook (FB) részvényárfolyamának előrejelzéséhez.

Tartalomjegyzék

Az alábbi tartalomjegyzék használatával ugorhat a Python visszatérő neurális hálózati oktatóanyagának egy adott szakaszára:

  • Az oktatóanyag adatkészletének letöltése
  • Az oktatóanyaghoz szükséges könyvtárak importálása
  • Képzési készletünk importálása a Python szkriptbe
  • Funkcióméretezés alkalmazása az adathalmazunkra
  • Időszakok számának meghatározása visszatérő ideghálózatunkhoz
  • Adatkészleteink véglegesítése átalakítva őket NumPy tömbökbe
  • A TensorFlow könyvtárak importálása
  • Kiújuló ideghálózatunk kiépítése
  • Az első LSTM réteg hozzáadása
  • Néhány kieséses szabályozás hozzáadása
  • Három további LSTM réteg hozzáadása a lemorzsolódás szabályozásával
  • A kimeneti réteg hozzáadása visszatérő neurális hálózatunkhoz
  • Ismétlődő neurális hálózatunk összeállítása
  • Az ismétlődő neurális hálózat felszerelése az edzéskészletre
  • Jóslatok készítése visszatérő idegi hálózatunkkal
  • Tesztadataink importálása
  • A tesztadatok összeállítása Jóslatokra van szükségünk
  • Tesztadataink méretezése
  • Tesztadataink csoportosítása
  • Valójában jóslatok készítése
  • A bemutató teljes kódja
  • Végső gondolatok

Az oktatóanyag adatkészletének letöltése

Az oktatóanyag folytatásához két letöltésre van szüksége két adatkészletre:

  • Képzési adatok összessége, amely információkat tartalmaz a Facebook részvényárfolyamáról 2015 elejétől 2019 végéig
  • Tesztadatok, amelyek információkat tartalmaznak a Facebook részvényárfolyamáról 2020 első hónapjában

Visszatérő ideghálózatunkat betanítják a 2015–2019-es adatokra, és az adatok előrejelzésére használják 2020 januárjától.

Az edzés- és tesztadatokat az alábbi linkek segítségével töltheti le:

  • Képzési adatok
  • Teszt adat

Ezen adatsorok mindegyike egyszerűen a Yahoo! Pénzügy. Így néznek ki (amikor a Microsoft Excel alkalmazásban megnyitják őket):

Példa adatkészletre, amelyet a visszatérő ideghálózatunk képzésére használunk

A fájlok letöltése után helyezze át azokat a könyvtárakat, amelyekben dolgozni szeretne, és nyisson meg egy Jupyter Notebookot.

Az oktatóanyaghoz szükséges könyvtárak importálása

Ez az oktatóanyag számos nyílt forráskódú Python könyvtár függvénye lesz, beleértve a NumPyt, a pandákat és a matplotlibet.

Indítsuk el a Python szkriptünket az alábbi könyvtárak importálásával:

 import numpy as np import pandas as pd import matplotlib.pyplot as plt 

Képzési készletünk importálása a Python szkriptbe

A következő elvégzendő feladat az adatkészletünk importálása a Python szkriptbe.

Kezdetben az adatkészletet pandák DataFrame-ként importáljuk a read_csvmódszer segítségével. Mivel azonban a kerasmodul TensorFlowcsak a NumPy tömböket fogadja el paraméterként, az adatstruktúrát importálás után kell átalakítani.

Kezdjük azzal, hogy a teljes .csvfájlt DataFrame-ként importáljuk :

 training_data = pd.read_csv('FB_training_data.csv') 

A DataFrame-et nézve észreveheti, hogy a Facebook részvényárfolyamának mérésére számos különféle módszert tartalmaz, beleértve a nyitási árat, a záróárat, a magas és az alacsony árakat, valamint a mennyiségi információkat:

Példa adatkészletre, amelyet a visszatérő ideghálózatunk képzésére használunk

A folytatás előtt ki kell választanunk egy bizonyos típusú részvényárat. Használjuk Close, ami a Facebook részvényeinek kiigazítatlan záróárát jelzi.

Most ki kell választanunk a DataFrame oszlopát, és egy NumPy tömbben kell tárolnunk. Itt van a parancs erre:

 training_data = training_data.iloc[:, 1].values 

Vegye figyelembe, hogy ez a parancs felülírja a training_datakorábban létrehozott meglévő változót.

Most training_datafuttatással ellenőrizheti, hogy változónk valóban NumPy tömb type(training_data), amelynek vissza kell térnie:

 numpy.ndarray 

Funkcióméretezés alkalmazása az adathalmazunkra

Vegyünk most egy kis időt arra, hogy bizonyos funkciók méretezését alkalmazzuk az adatkészletünkön.

Gyors frissítésként a főbb méretezés két fő módszerrel alkalmazható az adatkészletre:

  • Szabványosítás
  • Normalizálás

Normalizációt fogunk használni a visszatérő ideghálózatunk felépítéséhez, amely magában foglalja az adatkészlet minimális értékének levonását, majd elosztását az adatsor tartományával.

Itt van a matematikailag meghatározott normalizálási függvény:

Funkció skálázási normalizációs egyenlet

Szerencsére scikit-learnnagyon egyszerűvé teszi a normalizálás alkalmazását egy adatkészletre az MinMaxScalerosztálya segítségével.

Kezdjük azzal, hogy importáljuk ezt az osztályt a Python szkriptünkbe. Az MinMaxScalerosztály a (z) preprocessingmodul moduljában él scikit-learn, ezért az osztály importálására szolgáló parancs:

 from sklearn.preprocessing import MinMaxScaler 

Ezután létre kell hoznunk ennek az osztálynak a példányát. Az újonnan létrehozott objektumot az ún scaler. Változóhoz rendeljük . Ehhez az osztályhoz az alapértelmezett paramétereket fogjuk használni, ezért nem kell semmit átadnunk:

 scaler = MinMaxScaler() 

Mivel nem adott meg nem alapértelmezett paraméterekkel, ez skála adataink beállítani, hogy minden megfigyelés között 0és 1.

Létrehoztuk az scalerobjektumunkat, de training_dataadatkészletünket még nem méreteztük. Az fit_transformeredeti adatsor módosításához a módszert kell használnunk . Erre a következõ kijelentésre van szükség:

 training_data = scaler.fit_transform(training_data.reshape(-1, 1)) 

Időszakok számának meghatározása visszatérő ideghálózatunkhoz

A következő dolog, amit meg kell tennünk, hogy megadjuk a számunkat timesteps. Az időzítések meghatározzák, hogy hány korábbi megfigyelést kell figyelembe venni, amikor a visszatérő idegháló előrejelzést ad az aktuális megfigyelésről.

40Időbeli lépéseket fogunk használni ebben az oktatóanyagban. Ez azt jelenti, hogy minden napra, amelyet az ideghálózat megjósol, figyelembe veszi a kibocsátás meghatározásához az előző 40 napos részvényárfolyamokat. Ne feledje, hogy mivel egy adott hónapban csak ~ 20 kereskedési nap van, 40 időmérés használata azt jelenti, hogy az előző 2 hónap részvényáradataira támaszkodunk.

Tehát hogyan adhatjuk meg a Python szkripten belüli időmérések számát?

Két speciális adatstruktúra létrehozásával történik:

  • Az egyik adatstruktúra, amelyet hívunk x_training_data, és amely az adatsor utolsó 40 részvényárfolyam-megfigyelését tartalmazza. Ez az az adat, amelyet a visszatérő idegháló felhasználni fog az előrejelzésekhez.
  • Az egyik adatstruktúra, amelyet hívunk y_training_data, és amely a következő kereskedési nap részvényárfolyamát tartalmazza. Ezt az adatpontot próbálja megjósolni a visszatérő ideghálózat.

Először inicializáljuk ezeket az adatstruktúrákat üres Python listaként:

 x_training_data = [] y_training_data =[] 

Most a for ciklust használjuk a tényleges adatok feltöltésére ezekben a Python-listákban. Itt van a kód (a kód további magyarázatával a kódblokk után):

 for i in range(40, len(training_data)): x_training_data.append(training_data[i-40:i, 0]) y_training_data.append(training_data[i, 0]) 

Csomagoljuk ki a kódblokk összetevőit:

  • A range(40, len(training_data))függvény a for ciklust 40az edzésadatok utolsó indexéig iterálja .
  • A x_training_data.append(training_data[i-40:i, 0])vonal hatására a hurok a ciklus x_training_dataminden egyes iterációjához hozzáfűzi a 40 előző részvényárfolyamot .
  • Hasonlóképpen, az y_training_data.append(training_data[i, 0])okok miatt a hurok a következő napi részvényárfolyamot hozzáfűzi a hurok y_training_dataminden iterációjához.

Adatkészleteink véglegesítése átalakítva őket NumPy tömbökbe

A TensorFlow-t elsősorban a NumPy tömbökkel való együttműködésre tervezték. Emiatt az utolsó dolog, amit tennünk kell, az a két általunk létrehozott Python-lista átalakítása NumPy-tömbökké.

Szerencsére ez egyszerű. Egyszerűen be kell csomagolnia a Python listákat a np.arrayfüggvénybe. Itt van a kód:

 x_training_data = np.array(x_training_data) y_training_data = np.array(y_training_data) 

Az egyik fontos módja annak, hogy megbizonyosodhasson arról, hogy a parancsfájl rendeltetésszerűen fut-e, az, hogy ellenőrizze mindkét NumPy tömb alakját.

A x_training_datatömbnek kétirányú NumPy tömbnek kell lennie, egy dimenzióval 40(az időmérések száma) és a második dimenzióval len(training_data) - 40, amely 1218esetünkben ezt értékeli .

Hasonlóképpen, az y_training_dataobjektumnak egy egydimenziós NumPy hosszúságú tömbnek kell lennie 1218(ami megint csak az len(training_data) - 40).

A tömbök alakját az shapeattribútumuk kinyomtatásával ellenőrizheti :

 print(x_training_data.shape) print(y_training_data.shape) 

Ez kinyomtatja:

 (1218, 40) (1218,) 

Mindkét tömbnek megvan a várt mérete. Azonban x_training_datamég egyszer át kell alakítanunk az objektumunkat, mielőtt folytatnánk a visszatérő ideghálózatunk kiépítését.

Ennek oka az, hogy a TensorFlow-ban elérhető visszatérő neurális hálózati réteg csak nagyon meghatározott formátumban fogad el adatokat. A TensorFlow dokumentációját erről a témáról itt olvashatja el.

Az x_training_dataobjektum átformálásához az np.reshape metódust fogom használni. Ehhez a következő kódot kell megtenni:

 x_training_data = np.reshape(x_training_data, (x_training_data.shape[0], x_training_data.shape[1], 1)) 

Most nyomtassuk ki x_training_datamég egyszer az alakját :

 print(x_training_data.shape) 

Ez eredményezi:

 (1218, 40, 1) 

A tömbjeink a kívánt alakúak, így folytathatjuk visszatérő ideghálózatunk kiépítését.

A TensorFlow könyvtárak importálása

Mielőtt megkezdhetnénk visszatérő ideghálózatunk kiépítését, számos osztályt kell importálnunk a TensorFlow-ból. A folytatás előtt a következő utasításokat kell futtatnia:

 from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import LSTM from tensorflow.keras.layers import Dropout 

Kiújuló ideghálózatunk kiépítése

Itt az ideje, hogy kiépítsük visszatérő ideghálózatunkat.

Az első dolog, amit meg kell tenni, egy objektum inicializálása a TensorFlow Sequentialosztályából. Ahogy a neve is mutatja, az Sequentialosztály ideghálózatok kiépítésére szolgál, rétegek sorozatainak hozzáadásával.

Itt van a kód a visszatérő ideghálózat inicializálásához:

 rnn = Sequential() 

Mint a mesterséges neurális hálózatok és a konvolúciós neurális hálózatok esetében, a addmódszer segítségével további rétegeket adhatunk ehhez az ismétlődő neurális hálózathoz .

Az első LSTM réteg hozzáadása

Az első réteg, amelyet hozzáadunk, egy LSTM réteg. Ehhez adja át az LSTMosztály (amelyet most importáltunk) meghívását a addmódszerbe.

Az LSTMosztály több paramétert is elfogad. Pontosabban három érvet fogunk megadni:

  • Azon LSTM idegsejtek száma, amelyeket fel szeretne venni ebbe a rétegbe. Az idegsejtek számának növelése az egyik módszer a visszatérő idegháló dimenzióinak növelésére. Esetünkben meghatározzuk units = 45.
  • return_sequences = True- ezt mindig meg kell adni, ha egy másik LSTM réteget tervez felvenni a hozzáadandó után. Meg kell adnia return_sequences = Falsea visszatérő neurális hálózat utolsó LSTM rétegét.
  • input_shape: edzésadatainkban az időmérések száma és a prediktorok száma. Esetünkben 40időméréseket alkalmazunk, és csak 1előrejelzőt (részvényárfolyamot) használunk, ezért hozzáadjuk

Itt van a teljes addmódszer:

 rnn.add(LSTM(units = 45, return_sequences = True, input_shape = (x_training_data.shape[1], 1))) 

Ne feledje, hogy x_training_data.shape[1]a hardveresen kódolt érték helyett azt az esetet használtam , ha később úgy döntünk, hogy a visszatérő ideghálózatot nagyobb modellre oktatjuk.

Néhány kieséses szabályozás hozzáadása

A kieséses szabályozás az ideghálózatok edzésénél a túlfeszültség elkerülése érdekében alkalmazott technika.

Ez magában foglalja bizonyos réteg kimenetek véletlenszerű kizárását - vagy „kiesését” - az edzés szakaszában.

A TensorFlow megkönnyíti a lemorzsolódás-szabályozás megvalósítását Dropouta Python szkriptben korábban importált osztály használatával . Az Dropoutosztály egyetlen paramétert fogad el: a lemorzsolódást.

A lemorzsolódás azt jelzi, hogy hány idegsejtet kell ledobni az ideghálózat egy meghatározott rétegében. Gyakori a 20% -os lemorzsolódás. Ezt a konvenciót követni fogjuk visszatérő idegi hálózatunkban.

Az alábbiak szerint utasíthatja a TensorFlow-t, hogy az LSTM réteg neuronjának 20% -át dobja le az edzés minden egyes iterációja során:

 rnn.add(Dropout(0.2)) 

Három további LSTM réteg hozzáadása a lemorzsolódás szabályozásával

Most hozzáadunk még három LSTM réteget (kieséses szabályozással) visszatérő ideghálózatunkhoz. Látni fogja, hogy az első LSTM réteg megadása után a további hozzáadása triviális.

További rétegek hozzáadásához mindössze annyit kell tennie, hogy az első két addmódszert egyetlen apró változtatással lemásolja . Nevezetesen el kell távolítanunk az input_shapeargumentumot az LSTMosztályból.

Az idegsejtek számát (vagy units) és a lemorzsolódási arányt ugyanazon LSTMosztály-invokációknál tartjuk . Mivel az LSTMebben a szakaszban hozzáadott harmadik réteg lesz az utolsó LSTM rétegünk, a return_sequences = Truekorábban említett módon eltávolíthatjuk a paramétert. A paraméterkészletek eltávolítása az return_sequencesalapértelmezett értékre False.

Itt van a következő három LSTM réteg hozzáadásához szükséges teljes kód:

 rnn.add(LSTM(units = 45, return_sequences = True)) rnn.add(Dropout(0.2)) rnn.add(LSTM(units = 45, return_sequences = True)) rnn.add(Dropout(0.2)) rnn.add(LSTM(units = 45)) rnn.add(Dropout(0.2)) 

Ez a kód nagyon ismétlődő, és sérti a szoftverfejlesztés DRY (Ne ismételje meg magát) elvét. Helyezzük inkább hurokba:

 for i in [True, True, False]: rnn.add(LSTM(units = 45, return_sequences = i)) rnn.add(Dropout(0.2)) 

A kimeneti réteg hozzáadása visszatérő neurális hálózatunkhoz

Fejezzük be a visszatérő ideghálózatunk felépítését a kimeneti réteg hozzáadásával.

A kimeneti réteg az Denseosztály egy példánya lesz , amely ugyanaz az osztály, amelyet a konvolúciós ideghálózatunk teljes kapcsolati rétegének létrehozásához használtunk a tanfolyam elején.

Az egyetlen paraméter, amelyet meg kell adnunk units , az a kívánt dimenziószám, amelyet a kimeneti rétegnek generálnia kell. Mivel meg akarjuk adni a következő napi részvényárfolyamot (egyetlen értéket), megadjuk units = 1.

Itt van a kód a kimeneti réteg létrehozásához:

 rnn.add(Dense(units = 1)) 

Ismétlődő neurális hálózatunk összeállítása

Amint emlékeztet a mesterséges neurális hálózatok és a konvolúciós neurális hálózatok oktatóanyagaiból, a neurális hálózat kiépítésének összeállítási lépése az, ahol meghatározzuk az idegháló optimalizálóját és veszteségfüggvényét.

A TensorFlow lehetővé teszi számunkra, hogy ideghálót állítsunk össze a találóan elnevezett compilemódszerrel. Két érvet fogad el: optimizerés loss. Kezdjük egy üres compilefüggvény létrehozásával :

 rnn.compile(optimizer = '', loss = '') 

Most meg kell adnunk a optimizerés lossparamétereket.

Kezdjük a optimizerparaméter megbeszélésével . A visszatérő ideghálózatok általában az RMSProp optimalizálót használják fordítási szakaszukban. Ezzel elmondva az Adam optimalizálót fogjuk használni (mint korábban). Az Adam optimalizáló egy olyan munka ló optimalizáló, amely sokféle neurális hálózati architektúrában hasznos.

A lossparaméter meglehetősen egyszerű. Mivel folyamatos változót jósolunk, használhatunk átlagos négyzetes hibát - akárcsak egy lineáris regressziós gépi tanulási modell teljesítményének mérésekor. Ez azt jelenti, hogy megadhatjuk loss = mean_squared_error.

Itt van a végső compilemódszer:

 rnn.compile(optimizer = 'adam', loss = 'mean_squared_error') 

Az ismétlődő neurális hálózat felszerelése az edzéskészletre

Itt az ideje, hogy gyakorló hálózatunkat betanítsuk képzési adatainkra.

Ehhez a fitmódszert alkalmazzuk. A fitmódszer ebben az esetben négy érvet fogad el:

  • Az edzés adatai : esetünkben ez leszx_training_dataésy_training_data
  • Korszakok : az ismétlések száma, amelyeken a visszatérő ideghálózatot ki akarják képezni. Mi határozza megepochs = 100ebben az esetben.
  • A köteg mérete : azoknak a kötegeknek a mérete, amelyekben a hálózat minden korszakon át betanulásra kerül.

Itt van a kód, amellyel ezt a visszatérő ideghálózatot a specifikációink szerint képezhetjük:

 rnn.fit(x_training_data, y_training_data, epochs = 100, batch_size = 32) 

A Jupyter Notebook mostantól számos nyomtatott kimenetet generál a képzési algoritmus minden korszakához. Így néznek ki:

Gépi tanulási képzési eredmények

Mint láthatja, minden kimenet megmutatja, hogy mennyi időbe telt a korszak kiszámítása, valamint az adott korszak kiszámított veszteségfüggvénye.

Látnia kell, hogy a veszteségfüggvény értéke lassan csökken, mivel a visszatérő ideghálózat idővel illeszkedik az edzésadatokhoz. Esetemben a veszteségfüggvény értéke csökkent 0.0504az első iterációról 0.0017az utolsó iterációra.

Jóslatok készítése visszatérő idegi hálózatunkkal

Kiépítettük ismétlődő neurális hálózatunkat, és képeztük a Facebook részvényárfolyamára vonatkozó adatokra az elmúlt 5 évben. Itt az ideje néhány jóslatot tenni!

Tesztadataink importálása

Először is importáljuk a tényleges részvényáradatokat 2020 első hónapjára. Ez ad nekünk valamit, amihez összehasonlíthatjuk előrejelzett értékeinket.

Itt van a kód erre. Ne feledje, hogy nagyon hasonlít ahhoz a kódhoz, amelyet a Python szkriptünk elején használtunk az edzésadatok importálásához:

 test_data = pd.read_csv('FB_test_data.csv') test_data = test_data.iloc[:, 1].values 

Ha futtatja az utasítást print(test_data.shape), akkor visszatér (21,). Ez azt mutatja, hogy tesztadataink egydimenziós NumPy tömb, 21 bejegyzéssel - ami azt jelenti, hogy 2020 januárjában 21 tőzsdei kereskedési nap volt.

Az adatok segítségével gyorsan elkészítheti az adatok diagramját is plt.plot(test_data). Ennek a következő Python vizualizációt kell generálnia:

Vizsgálati adataink megjelenítése

Minden szerencsével előre jelzett értékeinknek ugyanazt az eloszlást kell követniük.

A tesztadatok összeállítása Jóslatokra van szükségünk

Mielőtt 2020 januárjában valóban előre jelezhetnénk a Facebook részvényárfolyamát, először változtatnunk kell az adatkészletünkön.

Ennek az az oka, hogy 21a januári megfigyelések mindegyikének megjóslásához szükségünk lesz az 40előző kereskedési napokra. Ezen kereskedési napok egy része a tesztkészletből származik, míg a fennmaradó rész a képzési készletből származik. Emiatt némi összefűzés szükséges.

Sajnos azonnal összekapcsolhatja a NumPy tömböket. Ez azért van, mert a jellemzők skálázását már alkalmaztuk az edzésadatokra, de a tesztadatokra nem alkalmaztunk funkciók skálázását.

Ennek kijavításához újra be kell importálnunk az eredeti x_training_dataobjektumot egy új változó néven unscaled_x_training_data. A következetesség érdekében a tesztadatokat DataFrame néven is újból importáljuk unscaled_test_data:

 unscaled_training_data = pd.read_csv('FB_training_data.csv') unscaled_test_data = pd.read_csv('FB_test_data.csv') 

Most összefoghatjuk az Openegyes DataFrame oszlopokat a következő állítással:

 all_data = pd.concat((unscaled_x_training_data['Open'], unscaled_test_data['Open']), axis = 0) 

Ez az all_dataobjektum egy 1279-es hosszúságú pandasorozat.

Most létre kell hoznunk egy tömböt az összes részvényárfolyamról 2020 januárjától és a január előtti 40 kereskedési naptól. Ezt az objektumot hívjuk, x_test_datamivel tartalmazza azokat az xértékeket, amelyeket a részvényár-előrejelzések készítésére használunk 2020 januárjára.

Az első dolog, amit meg kell tennie, hogy megtalálja a tárgyunkban található január első kereskedési napjának indexét all_data. Az utasítás len(all_data) - len(test_data)azonosítja ezt az indexet számunkra.

Ez a tömb első elemének felső határát jelenti. Az alsó határ eléréséhez csak vonjon le 40ebből a számból. Másképp mondva, az alsó határ az len(all_data) - len(test_data) - 40.

A teljes x_test_datatömb felső határa lesz az adatsor utolsó eleme. Ennek megfelelően ezt a NumPy tömböt a következő állítással hozhatjuk létre:

 x_test_data = all_data[len(all_data) - len(test_data) - 40:].values 

Meg tudja nézni e vagy sem ezt a tárgyat hoztak létre a kívánt nyomtatással len(x_test_data), amelynek értéke 61. Ennek van értelme - tartalmaznia kell a 212020 januári értékeket, valamint az azt 40megelőző értékeket.

Ennek a szakasznak az utolsó lépése a NumPy tömb gyors átalakítása, hogy ez alkalmas legyen a predictmódszerre:

 x_test_data = np.reshape(x_test_data, (-1, 1)) 

Ne feledje, hogy ha elhanyagolja ezt a lépést, a TensorFlow praktikus üzenetet nyomtat, amely pontosan elmagyarázza, hogyan kell átalakítania az adatait.

Tesztadataink méretezése

Visszatérő ideghálózatunkat skálázott adatokra oktattuk. Emiatt meg kell méreteznünk a x_test_dataváltozónkat, mielőtt a modellt jóslatokhoz használhatnánk.

 x_test_data = scaler.transform(x_test_data) 

Ne feledje, hogy transformitt a metódust használtuk a módszer helyett fit_transform(mint korábban). Ennek oka az, hogy a tesztadatokat a teljes edzésadatkészletből generált illeszkedés szerint akarjuk átalakítani.

Ez azt jelenti, hogy a tesztadatokra alkalmazott transzformáció megegyezik az edzésadatokkal alkalmazott átalakítással - ami a visszatérő ideghálózatunk számára szükséges a pontos előrejelzésekhez.

Tesztadataink csoportosítása

Az utolsó dolog, amit meg kell tennünk, a vizsgálati adataink 21nagyságú tömbökbe csoportosítása 40. Másképp fogalmazva, most létrehozunk egy tömböt, ahol minden bejegyzés megfelel egy januári dátumnak, és tartalmazza az 40előző kereskedési napok tőzsdei árfolyamát .

Az ehhez szükséges kód hasonló ahhoz, amit korábban használtunk:

 final_x_test_data = [] for i in range(40, len(x_test_data)): final_x_test_data.append(x_test_data[i-40:i, 0]) final_x_test_data = np.array(final_x_test_data) 

Végül át kell final_x_test_dataalakítanunk a változót, hogy megfeleljen a TensorFlow szabványoknak.

Korábban láttuk ezt, ezért a kódnak nem kell magyarázat:

 final_x_test_data = np.reshape(final_x_test_data, (final_x_test_data.shape[0], final_x_test_data.shape[1], 1)) 

Valójában jóslatok készítése

Abszurd mennyiségű adatfeldolgozás után most készen állunk előrejelzéseket tenni a tesztadataink segítségével!

Ez a lépés egyszerű. Egyszerűen adja át az final_x_test_dataobjektumunkat predictaz rnnobjektumra hívott módszerhez . Például, itt állíthatja elő, hogyan generálhatja ezeket az előrejelzéseket, és hogyan tárolhatja őket egy megnevezett változóban predictions:

 predictions = rnn.predict(final_x_test_data) 

plt.plot(predictions)Futtassuk ezeket az előrejelzéseket futtatással (vegye figyelembe, hogy plt.clf()először el kell futnia a vászon tisztításához):

Az eredeti jóslatok visszatérő ideghálózatunkból

Amint láthatja, ebben a diagramban a megjósolt értékek mind a 0és között vannak 1. Ennek oka, hogy az adathalmazunk még mindig méretezett! Le kell skáláznunk, hogy az előrejelzéseknek bármilyen gyakorlati jelentése is legyen.

Az MinMaxScalerosztály, amelyet eredetileg az adatkészletünk méretezéséhez használtunk, hasznos inverse_transformmódszerrel rendelkezik az adatok méretarányának megszüntetésére. A következőképpen vonhatja le az adatokat méretarányától, és új diagramot generálhat:

 unscaled_predictions = scaler.inverse_transform(predictions) plt.clf() #This clears the first prediction plot from our canvas plt.plot(unscaled_predictions) 
A visszatérő ideghálózatunk skálázatlan előrejelzései

Ez sokkal jobban néz ki! Aki bármikor követi a Facebook részvényárfolyamát, láthatja, hogy ez meglehetősen közelinek tűnik ahhoz a helyhez, ahol a Facebook valóban kereskedett.

Készítsünk olyan ábrát, amely összehasonlítja az előrejelzett részvényárakat a Facebook tényleges részvényárfolyamával:

 plt.plot(unscaled_predictions, color = '#135485', label = "Predictions") plt.plot(test_data, color = 'black', label = "Real Data") plt.title('Facebook Stock Price Predictions') 

A bemutató teljes kódja

Az oktatóanyag teljes kódját ebben a GitHub-tárban tekintheti meg. Az alábbiakban hivatkozásként beillesztjük:

 #Import the necessary data science libraries import numpy as np import pandas as pd import matplotlib.pyplot as plt #Import the data set as a pandas DataFrame training_data = pd.read_csv('FB_training_data.csv') #Transform the data set into a NumPy array training_data = training_data.iloc[:, 1].values #Apply feature scaling to the data set from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() training_data = scaler.fit_transform(training_data.reshape(-1, 1)) #Initialize our x_training_data and y_training_data variables #as empty Python lists x_training_data = [] y_training_data =[] #Populate the Python lists using 40 timesteps for i in range(40, len(training_data)): x_training_data.append(training_data[i-40:i, 0]) y_training_data.append(training_data[i, 0]) #Transforming our lists into NumPy arrays x_training_data = np.array(x_training_data) y_training_data = np.array(y_training_data) #Verifying the shape of the NumPy arrays print(x_training_data.shape) print(y_training_data.shape) #Reshaping the NumPy array to meet TensorFlow standards x_training_data = np.reshape(x_training_data, (x_training_data.shape[0], x_training_data.shape[1], 1)) #Printing the new shape of x_training_data print(x_training_data.shape) #Importing our TensorFlow libraries from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import LSTM from tensorflow.keras.layers import Dropout #Initializing our recurrent neural network rnn = Sequential() #Adding our first LSTM layer rnn.add(LSTM(units = 45, return_sequences = True, input_shape = (x_training_data.shape[1], 1))) #Perform some dropout regularization rnn.add(Dropout(0.2)) #Adding three more LSTM layers with dropout regularization for i in [True, True, False]: rnn.add(LSTM(units = 45, return_sequences = i)) rnn.add(Dropout(0.2)) #(Original code for the three additional LSTM layers) # rnn.add(LSTM(units = 45, return_sequences = True)) # rnn.add(Dropout(0.2)) # rnn.add(LSTM(units = 45, return_sequences = True)) # rnn.add(Dropout(0.2)) # rnn.add(LSTM(units = 45)) # rnn.add(Dropout(0.2)) #Adding our output layer rnn.add(Dense(units = 1)) #Compiling the recurrent neural network rnn.compile(optimizer = 'adam', loss = 'mean_squared_error') #Training the recurrent neural network rnn.fit(x_training_data, y_training_data, epochs = 100, batch_size = 32) #Import the test data set and transform it into a NumPy array test_data = pd.read_csv('FB_test_data.csv') test_data = test_data.iloc[:, 1].values #Make sure the test data's shape makes sense print(test_data.shape) #Plot the test data plt.plot(test_data) #Create unscaled training data and test data objects unscaled_training_data = pd.read_csv('FB_training_data.csv') unscaled_test_data = pd.read_csv('FB_test_data.csv') #Concatenate the unscaled data all_data = pd.concat((unscaled_x_training_data['Open'], unscaled_test_data['Open']), axis = 0) #Create our x_test_data object, which has each January day + the 40 prior days x_test_data = all_data[len(all_data) - len(test_data) - 40:].values x_test_data = np.reshape(x_test_data, (-1, 1)) #Scale the test data x_test_data = scaler.transform(x_test_data) #Grouping our test data final_x_test_data = [] for i in range(40, len(x_test_data)): final_x_test_data.append(x_test_data[i-40:i, 0]) final_x_test_data = np.array(final_x_test_data) #Reshaping the NumPy array to meet TensorFlow standards final_x_test_data = np.reshape(final_x_test_data, (final_x_test_data.shape[0], final_x_test_data.shape[1], 1)) #Generating our predicted values predictions = rnn.predict(final_x_test_data) #Plotting our predicted values plt.clf() #This clears the old plot from our canvas plt.plot(predictions) #Unscaling the predicted values and re-plotting the data unscaled_predictions = scaler.inverse_transform(predictions) plt.clf() #This clears the first prediction plot from our canvas plt.plot(unscaled_predictions) #Plotting the predicted values against Facebook's actual stock price plt.plot(unscaled_predictions, color = '#135485', label = "Predictions") plt.plot(test_data, color = 'black', label = "Real Data") plt.title('Facebook Stock Price Predictions') 

Összegzés - A visszatérő ideghálózatok mögött álló intuíció

Ebben az oktatóanyagban megtanulta, hogyan kell kiépíteni és kiképezni a visszatérő ideghálózatot.

Itt van egy rövid összefoglaló a tanultakról:

  • Hogyan alkalmazzuk a szolgáltatás méretezését egy olyan adatkészletre, amelyen egy visszatérő ideghálót ki fognak oktatni
  • A timestepsvisszatérő idegháló képzésének szerepe
  • Ez a TensorFlow elsősorban a NumPy tömböket használja adatstruktúraként a modellek képzéséhez
  • Hogyan adjunk LSTMés Dropoutrétegek visszatérő neurális hálózat
  • Miért használják általában a lemorzsolódást az ideghálózatok edzése során a túlillesztés elkerülése érdekében?
  • Azt, hogy Densea TensorFlow rétegét általában visszatérő ideghálózat kimeneti rétegeként használják
  • A compilationneurális hálózat kiépítésének lépésében meg kell adni annak optimalizálóját és veszteségfüggvényét
  • Hogyan lehet megjósolni visszatérő idegháló segítségével
  • Az előrejelzések alapján a skálázott adatokra betanított idegháló használatát le kell méretezni, hogy az emberek értelmezhetők legyenek

Ha hasznosnak találta ezt a bejegyzést, olvassa el a Pragmatikus gépi tanulás című könyvemet, amely egy projektalapú útmutató a mély tanulási modellekről itt és a többi cikkemben.

Pragmatikus gépi tanulás A gépi tanulás megváltoztatja a világot. De mindig nehéz volt megtanulni a gépi tanulást ... eddig. Aragmatikus gépi tanulás lépésről-lépésre ismerteti a gépi tanulás alapjait 9 valós projekt felépítésével. Megtudhatja: Lineáris regresszióLogisztikai regressi… Nick McCullum Gumroad