Den ultimative guide til tilbagevendende neurale netværk i Python

Tilbagevendende neurale netværk er modeller for dyb læring, der typisk bruges til at løse tidsserieproblemer. De bruges i selvkørende biler, højfrekvente handelsalgoritmer og andre virkelige applikationer.

Denne tutorial lærer dig de grundlæggende i tilbagevendende neurale netværk. Du bygger også dit eget tilbagevendende neurale netværk, der forudsiger morgendagens aktiekurs for Facebook (FB).

Intuitionen af ​​tilbagevendende neurale netværk

Tilbagevendende neurale netværk er et eksempel på det bredere felt af neurale netværk. Andre eksempler inkluderer:

  • Kunstige neurale netværk
  • Revolutionære neurale netværk

Denne artikel vil fokusere på tilbagevendende neurale netværk.

Denne tutorial begynder vores diskussion af tilbagevendende neurale netværk ved at diskutere intuitionen bag tilbagevendende neurale netværk.

Typerne af problemer løst af tilbagevendende neurale netværk

Selvom vi endnu ikke eksplicit har diskuteret det, er der generelt brede dele af problemer, som hver type neuralt netværk er designet til at løse:

  • Kunstige neurale netværk: klassificerings- og regressionsproblemer
  • Revolutionære neurale netværk: problemer med computersyn

I tilfælde af tilbagevendende neurale netværk bruges de typisk til at løse tidsserieanalyseproblemer.

Hver af disse tre typer neurale netværk (kunstige, konvolutions- og tilbagevendende) bruges til at løse overvågede maskinlæringsproblemer.

Kortlægning af neurale netværk til dele af den menneskelige hjerne

Som du husker, blev neurale netværk designet til at efterligne den menneskelige hjerne. Dette gælder både for deres konstruktion (både hjernen og neurale netværk er sammensat af neuroner) og deres funktion (de bruges begge til at træffe beslutninger og forudsigelser).

De tre hoveddele af hjernen er:

  • Hjernen
  • Hjernestammen
  • Lillehjernen

Formentlig den vigtigste del af hjernen er cerebrum. Den indeholder fire lapper:

  • Frontloben
  • Parietallappen
  • Den timelige lap
  • Den occipitale lap

Den vigtigste innovation, som neurale netværk indeholder, er idéen om vægte.

Sagt forskelligt er det vigtigste kendetegn ved hjernen, som neurale netværk har efterlignet, evnen til at lære af andre neuroner.

Evnen hos et neuralt netværk til at ændre sin vægt gennem hver epoke i dets træningstrin svarer til den langtidshukommelse, der ses hos mennesker (og andre dyr).

Den temporale lap er den del af hjernen, der er forbundet med langtidshukommelse. Separat var det kunstige neurale netværk den første type neuralt netværk, der havde denne langvarige hukommelsesegenskab. I denne forstand har mange forskere sammenlignet kunstige neurale netværk med den menneskelige hjernes temporale lap.

På samme måde er den occipitale lap den komponent i hjernen, der styrker vores vision. Da nedbrydningsneurale netværk typisk bruges til at løse problemer med computersyn, kan man sige, at de svarer til occipitallappen i hjernen.

Som nævnt bruges tilbagevendende neurale netværk til at løse tidsserieproblemer. De kan lære af begivenheder, der er sket i de seneste tidligere iterationer af deres træningsfase. På denne måde sammenlignes de ofte med hjernens frontlobe - som driver vores kortvarige hukommelse.

For at opsummere parrer forskere ofte hver af de tre neurale net med følgende dele af hjernen:

  • Kunstige neurale netværk: den temporale lap
  • Konvolutionsneurale netværk: den occipitale lap
  • Tilbagevendende neurale netværk: frontallappen

Sammensætningen af ​​et tilbagevendende neuralt netværk

Lad os nu diskutere sammensætningen af ​​et tilbagevendende neuralt netværk. Husk først, at sammensætningen af ​​et grundlæggende neuralt netværk har følgende udseende:

Et grundlæggende neuralt netværk

Den første ændring, der skal foretages i dette neurale netværk, er at hvert lag af netværket skal presses sammen som dette:

Et knust neuralt netværk

Derefter skal der foretages yderligere tre ændringer:

  • Det neurale netværks neuronsynapser skal forenkles til en enkelt linje
  • Hele det neurale netværk skal drejes 90 grader
  • Der skal genereres en sløjfe omkring det skjulte lag af det neurale net

Det neurale netværk vil nu have følgende udseende:

Et tilbagevendende neuralt netværk

Den linje, der cirkler det skjulte lag af det tilbagevendende neurale netværk, kaldes den timelige løkke. Det bruges til at indikere, at det skjulte lag ikke kun genererer et output, men at output tilføres tilbage som input i det samme lag.

En visualisering er nyttig til at forstå dette. Som du kan se i det følgende billede, bruges det skjulte lag, der bruges til en specifik observation af et datasæt, ikke kun til at generere et output til denne observation, men det bruges også til at træne det skjulte lag i den næste observation.

Et tidsserie tilbagevendende neuralt netværk

Denne egenskab ved en observation, der hjælper med at træne den næste observation, er, hvorfor tilbagevendende neurale netværk er så nyttige til at løse tidsserieanalyseproblemer.

Resumé - Intuitionen af ​​tilbagevendende neurale netværk

I denne vejledning havde du din første introduktion til tilbagevendende neurale netværk. Mere specifikt diskuterede vi intuitionen bag tilbagevendende neurale netværk.

Her er et kort resume af, hvad vi diskuterede i denne vejledning:

  • Typerne af problemer løst af tilbagevendende neurale netværk
  • Forholdet mellem de forskellige dele af hjernen og de forskellige neurale netværk, vi har studeret i dette kursus
  • Sammensætningen af ​​et tilbagevendende neuralt netværk og hvordan hvert skjult lag kan bruges til at hjælpe med at træne det skjulte lag fra den næste observation i datasættet

Det forsvindende gradientproblem i tilbagevendende neurale netværk

Det forsvindende gradientproblem har historisk været en af ​​de største barrierer for succesen med tilbagevendende neurale netværk.

På grund af dette er det vigtigt at have en forståelse af det forsvindende gradientproblem, før du bygger dit første RNN.

Dette afsnit forklarer det forsvindende gradientproblem på almindelig engelsk, herunder en diskussion af de mest nyttige løsninger på dette interessante problem.

Hvad er det forsvindende gradientproblem?

Før vi går i detaljer med det forsvindende gradientproblem, er det nyttigt at have en vis forståelse af, hvordan problemet oprindeligt blev opdaget.

Det forsvindende gradientproblem blev opdaget af Sepp Hochreiter, en tysk computerforsker, der har haft en indflydelsesrig rolle i udviklingen af ​​tilbagevendende neurale netværk inden for dyb læring.

Lad os nu undersøge det forsvindende gradientproblem i detaljer. Som navnet antyder, er det forsvindende gradientproblemer relateret til dyb læringsgradientafstamningsalgoritmer. Husk på, at en algoritme med gradientafstamning ser sådan ud:

En afsluttet algoritme til gradientafstamning

Denne gradientafstamningsalgoritme kombineres derefter med en backpropagationsalgoritme for at opdatere synapsvægtene i det neurale netværk.

Tilbagevendende neurale netværk opfører sig lidt anderledes, fordi det skjulte lag i en observation bruges til at træne det skjulte lag i den næste observation.

En tilbagevendende neuralt netværk gradient afstamningsalgoritme

Dette betyder, at omkostningsfunktionen for det neurale net beregnes for hver observation i datasættet. Disse omkostningsfunktionsværdier er vist øverst på følgende billede:

En tilbagevendende neuralt netværk gradient afstamningsalgoritme

Det forsvindende gradientproblem opstår, når backpropagationsalgoritmen bevæger sig tilbage gennem alle neuronerne i det neurale net for at opdatere deres vægte. Naturen af ​​tilbagevendende neurale netværk betyder, at omkostningsfunktionen beregnet på et dybt lag af det neurale netværk vil blive brugt til at ændre vægten af ​​neuroner ved lavere lag.

Matematikken, der beregner denne ændring, er multiplikativ, hvilket betyder, at den gradient, der beregnes i et trin, der er dybt inde i det neurale netværk, vil blive ganget tilbage gennem vægtene tidligere i netværket. Sagt forskelligt er gradienten beregnet dybt i netværket "fortyndet", når den bevæger sig tilbage gennem nettet, hvilket kan få gradienten til at forsvinde - hvilket giver navnet på det forsvindende gradientproblem!

Den faktiske faktor, der ganges gennem et tilbagevendende neuralt netværk i backpropagationsalgoritmen, refereres til af den matematiske variabel Wrec. Det skaber to problemer:

  • Når det Wrecer lille, oplever du et forsvindende gradientproblem
  • Når det Wrecer stort, oplever du et eksploderende gradientproblem

Bemærk, at begge disse problemer generelt omtales med det enklere navn på "forsvindende gradientproblem".

For at opsummere er problemet med forsvindende gradient forårsaget af multiplikativ karakter af backpropagationsalgoritmen. Det betyder, at gradienter beregnet på et dybt stadium af det tilbagevendende neurale netværk enten har for lille indvirkning (i et forsvindende gradientproblem) eller for stor indvirkning (i et eksploderende gradientproblem) på vægten af ​​neuroner, der er lavere i det neurale net.

Sådan løses det forsvindende gradientproblem

Der er en række strategier, der kan bruges til at løse det forsvindende gradientproblem. Vi vil undersøge strategier for både forsvindende gradient og eksploderende gradientproblemer hver for sig. Lad os starte med sidstnævnte.

Løsning af det eksploderende gradientproblem

For eksploderende gradienter er det muligt at bruge en modificeret version af den kaldte backpropagation-algoritme truncated backpropagation. Den trunkerede backpropagationsalgoritme begrænser det antal tidsspor, som backproporation udføres på, hvilket stopper algoritmen, før det eksploderende gradientproblem opstår.

Du kan også introducere penalties, som er hårdkodede teknikker til at reducere en backpropagations indflydelse, når den bevæger sig gennem overfladiske lag i et neuralt netværk.

Endelig kan du introducere gradient clipping, som introducerer et kunstigt loft, der begrænser, hvor stor gradienten kan blive i en backpropagationsalgoritme.

Løsning af det forsvindende gradientproblem

Vægtinitialisering er en teknik, der kan bruges til at løse det forsvindende gradientproblem. Det indebærer kunstigt at skabe en indledende værdi for vægte i et neuralt netværk for at forhindre backpropagationsalgoritmen i at tildele vægte, der er urealistisk små.

Du kan også bruge ekkotilstandsnetværk, som er en bestemt type neuralt netværk designet til at undgå det forsvindende gradientproblem. Echo state-netværk er uden for dette kursus omfang. At have viden om deres eksistens er tilstrækkelig for nu.

Den vigtigste løsning på det forsvindende gradientproblem er en specifik type neuralt netværk kaldet Long Short-Term Memory Networks (LSTM'er), som blev banebrydende af Sepp Hochreiter og Jürgen Schmidhuber. Husk at hr. Hochreiter var den videnskabsmand, der oprindeligt opdagede det forsvindende gradientproblem.

LSTM'er bruges i problemer primært relateret til talegenkendelse, hvor et af de mest bemærkelsesværdige eksempler er Google, der bruger en LSTM til talegenkendelse i 2015 og oplever et fald på 49% i transkriptionsfejl.

LSTM anses for at være det go-to neurale net for forskere, der er interesserede i at implementere tilbagevendende neurale netværk. Vi vil i vid udstrækning fokusere på LSTM'er gennem resten af ​​dette kursus.

Resume - Det forsvindende gradientproblem

I dette afsnit lærte du om det forsvindende gradientproblem ved tilbagevendende neurale netværk.

Her er et kort resume af det, vi diskuterede:

  • At Sepp Hochreiter var den første videnskabsmand, der opdagede det forsvindende gradientproblem i tilbagevendende neurale netværk
  • Hvad det forsvindende gradientproblem (og dets fætter, det eksploderende gradientproblem) indebærer
  • Rollen Wrecved at forsvinde gradientproblemer og eksploderende gradientproblemer
  • Hvordan forsvindende gradientproblemer og eksploderende gradientproblemer løses
  • LSTM'ers rolle som den mest almindelige løsning på det forsvindende gradientproblem

Lange kortvarige hukommelsesnetværk (LSTM'er)

Lange kortvarige hukommelsesnetværk (LSTM'er) er en type tilbagevendende neuralt netværk, der bruges til at løse det forsvindende gradientproblem.

De adskiller sig fra "regelmæssige" tilbagevendende neurale netværk på vigtige måder.

Denne vejledning introducerer dig til LSTM'er. Senere i dette kursus vil vi bygge og træne en LSTM fra bunden.

Indholdsfortegnelse

Du kan springe til et bestemt afsnit i denne LSTM-tutorial ved hjælp af nedenstående indholdsfortegnelse:

  • Historien om LSTM'er
  • Hvordan LSTM'er løser det forsvindende gradientproblem
  • Sådan fungerer LSTM'er
  • Variationer af LSTM-arkitekturer
  • Kighulsvariationen
  • The Coupled Gate Variation
  • Andre LSTM-variationer
  • Afsluttende tanker

Historien om LSTM'er

Som vi antydede i sidste afsnit, er de to vigtigste figurer inden for LSTM'er Sepp Hochreiter og Jürgen Schmidhuber.

Sidstnævnte var den tidligere ph.d.-vejleder ved det tekniske universitet i München i Tyskland.

Hochreiter's ph.d.-afhandling introducerede LSTM'er til verden for første gang.

Hvordan LSTM'er løser det forsvindende gradientproblem

I den sidste vejledning lærte vi, hvordan Wrecudtrykket i backpropagation-algoritmen kan føre til enten et forsvindende gradientproblem eller et eksploderende gradientproblem.

Vi undersøgte forskellige mulige løsninger på dette problem, herunder sanktioner, gradientafskæring og endda ekko-net. LSTM'er er den bedste løsning.

Så hvordan fungerer LSTM'er? De ændrer simpelthen værdien af Wrec.

I vores forklaring af det forsvindende gradientproblem lærte du, at:

  • Når det Wrecer lille, oplever du et forsvindende gradientproblem
  • Når det Wrecer stort, oplever du et eksploderende gradientproblem

Vi kan faktisk være meget mere specifikke:

  • Hvornår Wrec < 1oplever du et forsvindende gradientproblem
  • Hvornår Wrec > 1oplever du et eksploderende gradientproblem

Dette giver mening, hvis du tænker på den multiplikative karakter af backpropagationsalgoritmen.

Hvis du har et tal, der er mindre end, 1og du gang på gang med det mod sig selv, ender du med et tal, der forsvinder. Tilsvarende 1resulterer multiplikation af et tal større end mod sig selv mange gange i et meget stort antal.

For at løse dette problem indstilles LSTM'er Wrec = 1. Der er bestemt mere ved LSTMS end indstilling Wrec = 1, men dette er bestemt den vigtigste ændring, som denne specifikation af tilbagevendende neurale netværk foretager.

Sådan fungerer LSTM'er

Dette afsnit forklarer, hvordan LSTM'er fungerer. Før du fortsætter, er det værd at nævne, at jeg vil bruge billeder fra Christopher Olahs blogindlæg Understanding LSTMs, som blev offentliggjort i august 2015 og har nogle af de bedste LSTM-visualiseringer, jeg nogensinde har set.

For at starte, lad os overveje den grundlæggende version af et tilbagevendende neuralt netværk:

Et grundlæggende tilbagevendende neuralt netværk

Dette neurale netværk har neuroner og synapser, der transmitterer de vægtede summer af outputene fra et lag som input til det næste lag. En backpropagation-algoritme bevæger sig bagud gennem denne algoritme og opdaterer vægten af ​​hver neuron som svar på den omkostningsfunktion, der beregnes i hver periode af dets træningstrin.

I modsætning hertil ser sådan en LSTM ud:

En LSTM

Som du kan se, har en LSTM langt mere indlejret kompleksitet end et regelmæssigt tilbagevendende neuralt netværk. Mit mål er at give dig mulighed for fuldt ud at forstå dette billede, når du er færdig med denne tutorial.

Lad os først blive fortrolig med notationen i billedet ovenfor:

Notationen vi bruger i vores LSTM-tutorial

Nu hvor du har en fornemmelse af den notation, vi bruger i denne LSTM-tutorial, kan vi begynde at undersøge funktionaliteten af ​​et lag inden for et LSTM-neuralt net. Hvert lag har følgende udseende:

En knude fra et LSTM neuralt netværk

Før vi graver ind i funktionaliteten af ​​noder inden for et LSTM-neuralt netværk, er det værd at bemærke, at hvert input og output af disse dyb læringsmodeller er en vektor. I Python er dette generelt repræsenteret af et NumPy-array eller en anden endimensionel datastruktur.

Den første ting, der sker inden for en LSTM, er aktiveringsfunktionen af forget gate layer. Det ser på lagets input (mærket xttil observation og htoutput fra det tidligere lag i det neurale netværk) og output enten 1eller 0for hvert nummer i celletilstanden fra det forrige lag (mærket Ct-1).

Her er en visualisering af aktivering af forget gate layer:

En knude fra et LSTM neuralt netværk

Vi har ikke drøftet celletilstand endnu, så lad os gøre det nu. Celletilstand er repræsenteret i vores diagram ved den lange vandrette linje, der løber gennem toppen af ​​diagrammet. Som et eksempel er her celletilstanden i vores visualiseringer:

Celletilstand inden for LSTM-netværk

Cellestatens formål er at beslutte, hvilken information der skal videreføres fra de forskellige observationer, som et tilbagevendende neuralt netværk er uddannet på. Beslutningen om, hvorvidt information skal fremsendes eller ej, træffes af gates- hvoraf det forget gateer et godt eksempel. Hver port i en LSTM vil have følgende udseende:

Celletilstand inden for LSTM-netværk

Den σkarakter inden disse Porte refererer til den sigmoid funktion, som du sikkert har set anvendt i logistisk regression machine learning-modeller. Sigmoid-funktionen bruges som en type aktiveringsfunktion i LSTM'er, der bestemmer, hvilken information der sendes gennem en gate for at påvirke netværkets celletilstand.

Per definition kan Sigmoid-funktionen kun udlæse tal mellem 0og 1. Det bruges ofte til at beregne sandsynligheder på grund af dette. For LSTM-modeller specificeres det, hvor stor en andel af hver output der skal have indflydelse på salgstilstanden.

De næste to trin i en LSTM-model hænger tæt sammen: den input gate layerog den tanh layer. Disse lag arbejder sammen for at bestemme, hvordan celletilstanden skal opdateres. Samtidig er det sidste trin afsluttet, som gør det muligt for cellen at bestemme, hvad den sidste observation i datasættet skal glemmes.

Her er en visualisering af denne proces:

En knude fra et LSTM neuralt netværk

Det sidste trin i en LSTM bestemmer output for denne observation (betegnet ht). Dette trin løber gennem både en sigmoidfunktion og en hyperbolsk tangensfunktion. Det kan visualiseres som følger:

En knude fra et LSTM neuralt netværk

Dette afslutter processen med at træne et enkelt lag af en LSTM-model. Som du måske forestiller dig, er der masser af matematik under overfladen, som vi har glanset over. Pointen med dette afsnit er i vid udstrækning at forklare, hvordan LSTM'er fungerer, ikke for at du dybt forstår hver operation i processen.

Variationer af LSTM-arkitekturer

Jeg ønskede at afslutte denne vejledning ved at diskutere et par forskellige variationer af LSTM-arkitektur, der er lidt forskellige fra den grundlæggende LSTM, som vi hidtil har diskuteret.

Som en hurtig sammenfatning er her, hvordan en generaliseret knude til en LSTM ser ud:

En knude fra et LSTM neuralt netværk

Kighulsvariationen

Måske er den vigtigste variation i LSTM-arkitekturen peepholevarianten, der giver portlagene mulighed for at læse data fra celletilstanden.

Her er en visualisering af, hvordan kighulsvarianten kan se ud:

En knude fra et kighul LSTM neuralt netværk

Bemærk, at mens dette diagram tilføjer et kighul til hver gate i det tilbagevendende neurale netværk, kan du også tilføje kighuller til nogle porte og ikke andre porte.

The Coupled Gate Variation

Der er en anden variation af LSTM-arkitekturen, hvor modellen tager beslutningen om, hvad de skal glemme, og hvad de skal tilføje nye oplysninger sammen. I den originale LSTM-model blev disse beslutninger taget separat.

Her er en visualisering af, hvordan denne arkitektur ser ud:

En knude fra et koblet gate LSTM neuralt netværk

Andre LSTM-variationer

Dette er kun to eksempler på varianter til LSTM-arkitekturen. Der er mange flere. Et par er anført nedenfor:

  • Gated tilbagevendende enheder (GRU'er)
  • Dybdeforstyrrede RNN'er
  • Clockwork RNN'er

Resumé - Lange kortvarige hukommelsesnetværk

I denne vejledning havde du din første eksponering for lange kortvarige hukommelsesnetværk (LSTM'er).

Her er et kort resume af, hvad du har lært:

  • En (meget) kort historie om LSTM'er og den rolle, som Sepp Hochreiter og Jürgen Schmidhuber spillede i deres udvikling
  • Hvordan LSTM'er løser det forsvindende gradientproblem
  • Sådan fungerer LSTM'er
  • Portenes rolle, sigmoidfunktioner og den hyperbolske tangensfunktion i LSTM'er
  • Et par af de mest populære variationer af LSTM-arkitekturen

Sådan opbygges og trænes et tilbagevendende neuralt netværk

Indtil videre i vores diskussion af tilbagevendende neurale netværk har du lært:

  • Den grundlæggende intuition bag tilbagevendende neurale netværk
  • Det forsvindende gradientproblem, der historisk hindrede udviklingen af ​​tilbagevendende neurale netværk
  • Hvor lange korttidshukommelsesnetværk (LSTM'er) hjælper med at løse det forsvindende gradientproblem

Det er nu tid til at opbygge dit første tilbagevendende neurale netværk! Mere specifikt vil denne vejledning lære dig, hvordan du bygger og træner en LSTM til at forudsige aktiekursen på Facebook (FB).

Indholdsfortegnelse

Du kan springe til et specifikt afsnit i denne Python-tilbagevendende neurale netværksvejledning ved hjælp af nedenstående indholdsfortegnelse:

  • Download af datasættet til denne vejledning
  • Import af de biblioteker, du har brug for til denne vejledning
  • Import af vores træningssæt til Python-scriptet
  • Anvendelse af funktionsskalering i vores datasæt
  • Angivelse af antallet af tidspunkter for vores tilbagevendende neurale netværk
  • Færdiggørelse af vores datasæt ved at omdanne dem til NumPy-arrays
  • Import af vores TensorFlow-biblioteker
  • Opbygning af vores tilbagevendende neurale netværk
  • Tilføjelse af vores første LSTM-lag
  • Tilføjelse af nogle dropout-reguleringer
  • Tilføjelse af tre flere LSTM-lag med dropout-regulering
  • Tilføjelse af outputlaget til vores tilbagevendende neurale netværk
  • Kompilering af vores tilbagevendende neurale netværk
  • Montering af det tilbagevendende neurale netværk på træningssættet
  • Forudsigelser med vores tilbagevendende neurale netværk
  • Import af vores testdata
  • Opbygning af testdatasættet, vi skal forudsige
  • Skalering af vores testdata
  • Gruppering af vores testdata
  • Faktisk forudsigelse
  • Den fulde kode til denne vejledning
  • Afsluttende tanker

Download af datasættet til denne vejledning

For at fortsætte med denne vejledning skal du downloade to datasæt:

  • Et sæt træningsdata, der indeholder information om Facebooks aktiekurs fra starten af ​​2015 til slutningen af ​​2019
  • Et sæt testdata, der indeholder information om Facebooks aktiekurs i den første måned i 2020

Vores tilbagevendende neurale netværk trænes i 2015-2019-dataene og vil blive brugt til at forudsige dataene fra januar 2020.

Du kan downloade træningsdata og testdata ved hjælp af nedenstående links:

  • Træningsdata
  • Testdata

Hvert af disse datasæt er simpelthen eksport fra Yahoo! Finansiere. De ser sådan ud (når de åbnes i Microsoft Excel):

Et eksempel på datasæt, som vi bruger til at træne vores tilbagevendende neurale netværk

Når filerne er downloadet, skal du flytte dem til det bibliotek, du gerne vil arbejde i, og åbne en Jupyter Notebook.

Import af de biblioteker, du har brug for til denne vejledning

Denne tutorial afhænger af et antal open source Python-biblioteker, herunder NumPy, pandas og matplotlib.

Lad os starte vores Python-script ved at importere nogle af disse biblioteker:

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

Import af vores træningssæt til Python-scriptet

Den næste opgave, der skal afsluttes, er at importere vores datasæt til Python-scriptet.

Vi importerer oprindeligt datasættet som en pandas DataFrame ved hjælp af read_csvmetoden. Da kerasmodulet TensorFlowkun accepterer NumPy-arrays som parametre, skal datastrukturen dog transformeres efter import.

Lad os starte med at importere hele .csvfilen som en DataFrame:

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

Du vil bemærke, når du ser på DataFrame, at den indeholder adskillige forskellige måder til måling af Facebooks aktiekurs, herunder åbningskurs, lukkekurs, høje og lave priser og volumenoplysninger:

Et eksempel på datasæt, som vi bruger til at træne vores tilbagevendende neurale netværk

Vi bliver nødt til at vælge en bestemt type aktiekurs, inden vi fortsætter. Lad os bruge Close, hvilket angiver den ujusterede slutkurs for Facebook's aktie.

Nu skal vi vælge den kolonne i DataFrame og gemme den i et NumPy-array. Her er kommandoen til at gøre dette:

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

Bemærk, at denne kommando overskriver den eksisterende training_datavariabel, som vi tidligere havde oprettet.

Du kan nu kontrollere, at vores training_datavariabel faktisk er et NumPy-array ved at køre type(training_data), som skal returnere:

 numpy.ndarray 

Anvendelse af funktionsskalering i vores datasæt

Lad os nu tage lidt tid på at anvende funktionsskalering til vores datasæt.

Som en hurtig genopfriskning er der to hovedmåder, du kan anvende skalering af featuer på dit datasæt:

  • Standardisering
  • Normalisering

Vi bruger normalisering til at opbygge vores tilbagevendende neurale netværk, som involverer at trække datasættets minimumsværdi og derefter dividere med datasættets rækkevidde.

Her er normaliseringsfunktionen defineret matematisk:

Funktionsskalering af normaliseringsligning

Heldigvis scikit-learngør det meget let at anvende normalisering til et datasæt ved hjælp af sin MinMaxScalerklasse.

Lad os starte med at importere denne klasse til vores Python-script. Den MinMaxScalerklasse bor i preprocessingmodulet af scikit-learn, så kommandoen til at importere klassen er:

 from sklearn.preprocessing import MinMaxScaler 

Dernæst skal vi oprette en forekomst af denne klasse. Vi tildeler det nyoprettede objekt til en kaldet variabel scaler. Vi bruger standardparametrene til denne klasse, så vi behøver ikke videregive noget til:

 scaler = MinMaxScaler() 

Da vi ikke har angivet nogen ikke-standardparametre, skalerer dette vores datasæt, så hver observation er mellem 0og 1.

Vi har oprettet vores scalerobjekt, men vores training_datadatasæt er endnu ikke skaleret. Vi er nødt til at bruge fit_transformmetoden til at ændre det originale datasæt. Her er udsagnet om at gøre dette:

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

Angivelse af antallet af tidspunkter for vores tilbagevendende neurale netværk

Den næste ting, vi skal gøre er at specificere vores antal timesteps. Timesteps specificerer, hvor mange tidligere observationer der skal overvejes, når det tilbagevendende neurale netværk giver en forudsigelse om den aktuelle observation.

Vi bruger 40timesteps i denne vejledning. Dette betyder, at det for hver dag, som det neurale netværk forudsiger, vil overveje de foregående 40 dages aktiekurser for at bestemme dets produktion. Bemærk, at da der kun er ~ 20 handelsdage i en given måned, betyder det, at vi bruger 40 tidspunkter, at vi stoler på aktiekursdata fra de foregående 2 måneder.

Så hvordan specificerer vi faktisk antallet af tidsspor i vores Python-script?

Det gøres ved at oprette to specielle datastrukturer:

  • En datastruktur, som vi kalder, og x_training_datasom indeholder de sidste 40 observationer af aktiekurser i datasættet. Dette er de data, som det tilbagevendende neurale netværk bruger til at forudsige.
  • En datastruktur, som vi kalder, og y_training_datasom indeholder aktiekursen for den næste handelsdag. Dette er datapunktet, som det tilbagevendende neurale netværk forsøger at forudsige.

For at starte, lad os initialisere hver af disse datastrukturer som en tom Python-liste:

 x_training_data = [] y_training_data =[] 

Nu bruger vi en for-løkke til at udfylde de faktiske data i hver af disse Python-lister. Her er koden (med yderligere forklaring af koden efter kodeblokken):

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

Lad os pakke ud komponenterne i denne kodeblok:

  • Den range(40, len(training_data))Funktionen bevirker, at for-løkke til iterate fra 40til den sidste indeks af uddannelsen data.
  • Den x_training_data.append(training_data[i-40:i, 0])linje får løkken til at tilføje de 40 foregående aktiekurser til x_training_datamed hver iteration af løkken.
  • Tilsvarende y_training_data.append(training_data[i, 0])får årsagen til, at sløjfen tilføjes den næste dags aktiekurs til y_training_datahver iteration af sløjfen.

Færdiggørelse af vores datasæt ved at omdanne dem til NumPy-arrays

TensorFlow er designet til primært at arbejde med NumPy-arrays. På grund af dette er den sidste ting, vi skal gøre, at omdanne de to Python-lister, vi lige har oprettet, til NumPy-arrays.

Heldigvis er dette simpelt. Du skal blot indpakke Python-listerne i np.arrayfunktionen. Her er koden:

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

En vigtig måde, du kan sikre dig, at dit script kører som beregnet, er at kontrollere formen på begge NumPy-arrays.

Den x_training_dataarray skal være en to-directional NumPy array med en dimension væsen 40(antallet af timesteps) og den anden dimension væsen len(training_data) - 40, som evaluerer til 1218i vores tilfælde.

På samme måde skal y_training_dataobjektet være et endimensionalt NumPy-array med længde 1218(hvilket igen er len(training_data) - 40).

Du kan kontrollere formen på arrays ved at udskrive deres shapeattribut på denne måde:

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

Dette udskriver:

 (1218, 40) (1218,) 

Begge arrays har de dimensioner, du forventer. Vi er dog nødt til at omforme vores x_training_dataobjekt en gang til, før vi fortsætter med at opbygge vores tilbagevendende neurale netværk.

Årsagen til dette er, at det tilbagevendende neurale netværkslag, der er tilgængeligt i TensorFlow, kun accepterer data i et meget specifikt format. Du kan læse dokumentationen til TensorFlow om dette emne her.

For at omforme x_training_dataobjektet bruger jeg np.reshape-metoden. Her er koden til at gøre dette:

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

Lad os nu udskrive formen på x_training_dataigen:

 print(x_training_data.shape) 

Dette output:

 (1218, 40, 1) 

Vores arrays har den ønskede form, så vi kan fortsætte med at opbygge vores tilbagevendende neurale netværk.

Import af vores TensorFlow-biblioteker

Før vi kan begynde at opbygge vores tilbagevendende neurale netværk, skal vi importere et antal klasser fra TensorFlow. Her er de udsagn, du skal køre, før du fortsætter:

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

Opbygning af vores tilbagevendende neurale netværk

Det er nu tid til at opbygge vores tilbagevendende neurale netværk.

Det første, der skal gøres, er at initialisere et objekt fra TensorFlow's Sequentialklasse. Som navnet antyder, er Sequentialklassen designet til at opbygge neurale netværk ved at tilføje sekvenser af lag over tid.

Her er koden til at initialisere vores tilbagevendende neurale netværk:

 rnn = Sequential() 

Som med vores kunstige neurale netværk og nedbrydningsneurale netværk kan vi tilføje flere lag til dette tilbagevendende neurale netværk ved hjælp af addmetoden.

Tilføjelse af vores første LSTM-lag

Det første lag, som vi tilføjer, er et LSTM-lag. For at gøre dette skal du sende en påkaldelse af LSTMklassen (som vi lige har importeret) til addmetoden.

Den LSTMklasse accepterer flere parametre. Mere præcist vil vi specificere tre argumenter:

  • Antallet af LSTM-neuroner, som du gerne vil medtage i dette lag. At øge antallet af neuroner er en metode til at øge dimensionaliteten af ​​dit tilbagevendende neurale netværk. I vores tilfælde vil vi specificere units = 45.
  • return_sequences = True- dette skal altid specificeres, hvis du planlægger at medtage endnu et LSTM-lag efter det, du tilføjer. Du skal angive return_sequences = Falsedet sidste LSTM-lag i dit tilbagevendende neurale netværk.
  • input_shape: antallet af timesteps og antallet af forudsigere i vores træningsdata. I vores tilfælde bruger vi tidspunkter 40og kun 1forudsigelse (aktiekurs), så vi tilføjer

Her er den fulde addmetode:

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

Bemærk, at jeg brugte i x_training_data.shape[1]stedet for den hårdkodede værdi, hvis vi beslutter at træne det tilbagevendende neurale netværk på en større model på et senere tidspunkt.

Tilføjelse af nogle dropout-reguleringer

Dropout-regulering er en teknik, der bruges til at undgå overmontering ved træning af neurale netværk.

Det indebærer tilfældigt at udelukke - eller "droppe ud" - visse lagudgange under træningstrinnet.

TensorFlow gør det let at implementere dropout-regulering ved hjælp af den Dropoutklasse, som vi importerede tidligere i vores Python-script. Den Dropoutklasse accepterer et enkelt parameter: frafaldet.

Frafaldshastigheden angiver, hvor mange neuroner der skal droppes i et specifikt lag i det neurale netværk. Det er almindeligt at bruge et frafald på 20%. Vi vil følge denne konvention i vores tilbagevendende neurale netværk.

Sådan kan du instruere TensorFlow om at droppe 20% af LSTM-lagets neuron under hver iteration af træningstrinnet:

 rnn.add(Dropout(0.2)) 

Tilføjelse af tre flere LSTM-lag med dropout-regulering

Vi vil nu tilføje yderligere tre LSTM-lag (med dropout-regulering) til vores tilbagevendende neurale netværk. Du vil se, at efter at have specificeret det første LSTM-lag, er tilføjelse af mere trivielt.

For at tilføje flere lag er alt, hvad der skal gøres, at kopiere de to første addmetoder med en lille ændring. Vi skal nemlig fjerne input_shapeargumentet fra LSTMklassen.

Vi vil holde antallet af neuroner (eller units) og frafaldsprocenten det samme i hver af LSTMklasseopkaldene. Da det tredje LSTMlag, vi tilføjer i dette afsnit, vil være vores sidste LSTM-lag, kan vi fjerne return_sequences = Trueparameteren som nævnt tidligere. Fjernelse af parameter indstilles return_sequencestil standardværdien på False.

Her er den fulde kode for at tilføje vores næste tre LSTM-lag:

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

Denne kode er meget gentagen og overtræder DRY (Don't repeat yourself) -princippet om softwareudvikling. Lad os reden i en løkke i stedet:

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

Tilføjelse af outputlaget til vores tilbagevendende neurale netværk

Lad os afslutte arkitekturen af ​​vores tilbagevendende neurale netværk ved at tilføje vores outputlag.

Outputlaget vil være en forekomst af Denseklassen, hvilket er den samme klasse, som vi brugte til at oprette det fulde forbindelseslag i vores sammenblandede neurale netværk tidligere i dette kursus.

Den eneste parameter, vi skal specificere, er units , hvilket er det ønskede antal dimensioner, som outputlaget skal generere. Da vi vil udsende den næste dags aktiekurs (en enkelt værdi), specificerer vi units = 1.

Her er koden til at oprette vores outputlag:

 rnn.add(Dense(units = 1)) 

Kompilering af vores tilbagevendende neurale netværk

Som du husker fra vejledningerne om kunstige neurale netværk og nedviklede neurale netværk, er kompileringstrinet for at opbygge et neuralt netværk, hvor vi specificerer neuronetets optimerings- og tabsfunktion.

TensorFlow giver os mulighed for at kompilere et neuralt netværk ved hjælp af den passende navnede compilemetode. Den accepterer to argumenter: optimizerog loss. Lad os starte med at oprette en tom compilefunktion:

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

Vi har nu brug for at angive optimizerog lossparametre.

Lad os starte med at diskutere optimizerparameteren. Tilbagevendende neurale netværk bruger typisk RMSProp optimizer i deres kompileringsfase. Når det er sagt, vil vi bruge Adam optimizer (som før). Adam optimizer er en arbejdshestoptimering, der er nyttig i en lang række neurale netværksarkitekturer.

Den lossparameter er forholdsvis enkel. Da vi forudsiger en kontinuerlig variabel, kan vi bruge en gennemsnitlig kvadratfejl - ligesom du ville, når du måler ydeevnen for en lineær regression maskineindlæringsmodel. Dette betyder, at vi kan specificere loss = mean_squared_error.

Her er den sidste compilemetode:

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

Montering af det tilbagevendende neurale netværk på træningssættet

Det er nu tid til at træne vores tilbagevendende netværk i vores træningsdata.

For at gøre dette bruger vi fitmetoden. Den fitmetode accepterer fire argumenter i denne sag:

  • Træningsdataene : i vores tilfælde vil dette værex_training_dataogy_training_data
  • Epoker : antallet af iterationer, du gerne vil have det tilbagevendende neurale netværk, der skal trænes i. Vi specificererepochs = 100i dette tilfælde.
  • Batchstørrelsen : størrelsen på batches, som netværket vil blive trænet i gennem hver epoke.

Her er koden til at træne dette tilbagevendende neurale netværk i henhold til vores specifikationer:

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

Din Jupyter Notebook genererer nu et antal trykte output til hver epoke i træningsalgoritmen. De ser sådan ud:

Træningsoutputs til maskinlæring

Som du kan se, viser hver output, hvor lang tid det tog at beregne såvel som den beregnede tabsfunktion i den periode.

Du bør se, at tabsfunktionens værdi langsomt falder, da det tilbagevendende neurale netværk er tilpasset træningsdataene over tid. I mit tilfælde faldt tabsfunktionens værdi fra 0.0504i den første iteration til 0.0017den sidste iteration.

Forudsigelser med vores tilbagevendende neurale netværk

Vi har opbygget vores tilbagevendende neurale netværk og trænet det i data om Facebooks aktiekurs i løbet af de sidste 5 år. Det er nu tid til at komme med nogle forudsigelser!

Import af vores testdata

Lad os starte med at importere de faktiske aktiekursdata for den første måned i 2020. Dette giver os noget at sammenligne vores forudsagte værdier med.

Her er koden til at gøre dette. Bemærk, at det er meget lig den kode, som vi brugte til at importere vores træningsdata i starten af ​​vores Python-script:

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

Hvis du kører erklæringen print(test_data.shape), vender den tilbage (21,). Dette viser, at vores testdata er et endimensionelt NumPy-array med 21 poster - hvilket betyder, at der var 21 børsdage i januar 2020.

Du kan også generere et hurtigt plot af dataene ved hjælp af plt.plot(test_data). Dette skulle generere følgende Python-visualisering:

En visualisering af vores testdata

Med held og lykke skal vores forudsagte værdier følge den samme fordeling.

Opbygning af testdatasættet, vi skal forudsige

Før vi rent faktisk kan forudsige Facebook-aktiekursen i januar 2020, skal vi først foretage nogle ændringer i vores datasæt.

Årsagen til dette er, at 21vi har brug for de 40foregående handelsdage for at forudsige hver af observationerne i januar . Nogle af disse handelsdage kommer fra testsættet, mens resten kommer fra træningssættet. På grund af dette er en vis sammenkædning nødvendig.

Desværre kan du bare sammenkæde NumPy-arrays straks. Dette skyldes, at vi allerede har anvendt funktionsskalering til træningsdataene, men ikke har anvendt nogen funktionsskalering til testdataene.

For at løse dette skal vi genimportere det originale x_training_dataobjekt under et nyt variabelnavn, der hedder unscaled_x_training_data. For konsistens vil vi også genimportere testdataene som en DataFrame kaldet unscaled_test_data:

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

Nu kan vi sammenkæde Openkolonnen fra hver DataFrame med følgende udsagn:

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

Dette all_dataobjekt er en panda serie af længde 1279.

Nu skal vi oprette en matrix med alle aktiekurser fra januar 2020 og de 40 handelsdage før januar. Vi kalder dette objekt, x_test_datada det indeholder de xværdier, som vi bruger til at forudsige aktiekurs i januar 2020.

Den første ting du skal gøre er at finde indekset for den første handelsdag i januar inden for vores all_datamål. Erklæringen len(all_data) - len(test_data)identificerer dette indeks for os.

Dette repræsenterer den øvre grænse for det første element i arrayet. For at få den nedre grænse skal du bare trække 40fra dette tal. Sagt forskelligt er den nedre grænse len(all_data) - len(test_data) - 40.

Den øvre grænse for hele x_test_dataarrayet vil være det sidste element i datasættet. Derfor kan vi oprette dette NumPy-array med følgende udsagn:

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

Du kan kontrollere, om dette objekt er oprettet som ønsket ved udskrivning len(x_test_data), som har en værdi på 61. Dette giver mening - det skal indeholde 21værdierne for januar 2020 såvel som 40værdierne forud.

Det sidste trin i dette afsnit er at hurtigt omforme vores NumPy-array for at gøre det egnet til predictmetoden:

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

Bemærk, at hvis du forsømte at udføre dette trin, vil TensorFlow udskrive en praktisk besked, der forklarer nøjagtigt, hvordan du har brug for at omdanne dine data.

Skalering af vores testdata

Vores tilbagevendende neurale netværk blev trænet i skalerede data. På grund af dette skal vi skalere vores x_test_datavariabel, før vi kan bruge modellen til at forudsige.

 x_test_data = scaler.transform(x_test_data) 

Bemærk, at vi brugte transformmetoden her i stedet for fit_transformmetoden (som før). Dette skyldes, at vi vil transformere testdataene i henhold til den pasform, der genereres fra hele træningsdatasættet.

Dette betyder, at transformationen, der anvendes på testdataene, vil være den samme som den, der anvendes på træningsdataene - hvilket er nødvendigt for, at vores tilbagevendende neurale netværk kan foretage nøjagtige forudsigelser.

Gruppering af vores testdata

Den sidste ting, vi skal gøre, er at gruppere vores testdata i 21arrays af størrelse 40. Sagt forskelligt opretter vi nu en matrix, hvor hver post svarer til en dato i januar og indeholder aktiekurserne for de 40foregående handelsdage.

Koden til at gøre dette svarer til noget, vi brugte tidligere:

 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) 

Endelig er vi nødt til at omforme final_x_test_datavariablen for at opfylde TensorFlow-standarder.

Vi så dette tidligere, så koden skal ikke behøves forklaret:

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

Faktisk forudsigelse

Efter en absurd mængde databehandling er vi nu klar til at forudsige ved hjælp af vores testdata!

Dette trin er simpelt. Bare final_x_test_datasend vores objekt ind i predictmetoden, der kaldes på rnnobjektet. Som et eksempel er her, hvordan du kan generere disse forudsigelser og gemme dem i en passende navngivet variabel kaldet predictions:

 predictions = rnn.predict(final_x_test_data) 

Lad os plotte disse forudsigelser ved at køre plt.plot(predictions)(bemærk, at du først skal køre for plt.clf()at rydde dit lærred):

De originale forudsigelser fra vores tilbagevendende neurale netværk

Som du kan se, er de forudsagte værdier i dette plot alle imellem 0og 1. Dette skyldes, at vores datasæt stadig er skaleret! Vi er nødt til at opskalere det for at forudsigelserne skal have nogen praktisk betydning.

Den MinMaxScalerklasse, som vi tidligere brugte til at skalere vores datasæt, kommer med en nyttig inverse_transformmetode til at fjerne skalering af dataene. Sådan kan du fjerne skalering af dataene og generere et nyt plot:

 unscaled_predictions = scaler.inverse_transform(predictions) plt.clf() #This clears the first prediction plot from our canvas plt.plot(unscaled_predictions) 
De uskalerede forudsigelser fra vores tilbagevendende neurale netværk

Dette ser meget bedre ud! Enhver, der har fulgt Facebooks aktiekurs i en længere periode, kan se, at dette virker ret tæt på, hvor Facebook faktisk har handlet.

Lad os generere plot, der sammenligner vores forventede aktiekurser med Facebooks faktiske aktiekurs:

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

Den fulde kode til denne vejledning

Du kan se den fulde kode til denne vejledning i dette GitHub-arkiv. Det er også indsat nedenfor til din reference:

 #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') 

Resumé - Intuitionen bag tilbagevendende neurale netværk

I denne vejledning lærte du at opbygge og træne et tilbagevendende neuralt netværk.

Her er et kort resume af, hvad du har lært:

  • Sådan anvendes funktionsskalering til et datasæt, som et tilbagevendende neuralt netværk vil blive trænet i
  • Rollen timestepsi at træne et tilbagevendende neuralt netværk
  • At TensorFlow primært bruger NumPy-arrays som datastruktur til at træne modeller med
  • Sådan tilføjes LSTMog Dropoutlag til et tilbagevendende neuralt netværk
  • Hvorfor udbredelsesregularisering ofte bruges til at undgå overmontering, når man træner neurale netværk
  • At Denselaget fra TensorFlow almindeligvis bruges som outputlaget i et tilbagevendende neuralt netværk
  • At compilationtrinnet med at opbygge et neuralt netværk indebærer at specificere dets optimering og dens tabsfunktion
  • Sådan foretages forudsigelser ved hjælp af et tilbagevendende neuralt netværk
  • At forudsigelser gør brug af et neuralt netværk, der er trænet i skalerede data, skal ikke skaleres for at kunne fortolkes af mennesker

Hvis du fandt dette indlæg nyttigt, skal du tjekke min bog Pragmatic Machine Learning for en projektbaseret guide til dyb læringsmodeller, der er dækket her og i mine andre artikler.

Pragmatisk maskinindlæring Maskinindlæring ændrer verden. Men det har altid været svært at lære maskinindlæring ... indtil nu. Pragmatisk maskinindlæring er en trinvis vejledning, der lærer dig grundlæggende maskinindlæring gennem opbygning af 9 virkelige projekter. Du lærer: Lineær regression Logistisk regressi ... Nick McCullum Gumroad