RNN (recurrent Neural Network) õpetus: TensorFlow näide
Evelyn Clarke
Miks me vajame korduvat närvivõrku (RNN)?
Korduv närvivõrk (RNN) võimaldab teil modelleerida mäluüksusi, et säilitada andmeid ja modelleerida lühiajalisi sõltuvusi. Seda kasutatakse ka aegridade prognoosimisel andmete korrelatsioonide ja mustrite tuvastamiseks. Samuti aitab see toota ennustavaid tulemusi järjestikuste andmete jaoks, pakkudes inimese ajuga sarnast käitumist.
Tehisnärvivõrgu struktuur on suhteliselt lihtne ja hõlmab peamiselt maatriksi korrutamist. Esimeses etapis korrutatakse sisendid algselt juhuslike kaaludega ja nihe, teisendatakse aktiveerimisfunktsiooniga ja väljundväärtusi kasutatakse prognoosi tegemiseks. See samm annab aimu, kui kaugel võrk tegelikkusest on.
Kasutatud mõõdik on kahjum. Mida suurem on kadufunktsioon, seda rumalam on mudel. Võrgu tundmise parandamiseks on vaja mõningast optimeerimist, kohandades võrgu kaalusid. Stohhastilise gradiendi laskumine on meetod, mida kasutatakse kaalude väärtuste muutmiseks õiges suunas. Kui kohandamine on tehtud, saab võrk kasutada oma uute teadmiste testimiseks teist andmehulka.
Viga on õnneks väiksem kui varem, kuid mitte piisavalt väike. Optimeerimise etappi tehakse iteratiivselt, kuni viga on minimeeritud, st rohkem teavet ei saa välja võtta.
Seda tüüpi mudelite probleem seisneb selles, et sellel pole mälu. See tähendab, et sisend ja väljund on sõltumatud. Teisisõnu, modell ei hooli sellest, mis oli varem. Kui teil on vaja aegridu või lauseid ennustada, tekib küsimus, kuna võrgul peab olema teave ajalooliste andmete või minevikusõnade kohta.
Selle probleemi lahendamiseks on välja töötatud uut tüüpi arhitektuur: korduv närvivõrk (edaspidi RNN)
Mis on korduv närvivõrk (RNN)?
A Korduv närvivõrk (RNN) on klass Kunstlik närvivõrk milles erinevate sõlmede vaheline ühendus moodustab ajalise dünaamilise käitumise andmiseks suunatud graafiku. See aitab modelleerida edastusvõrkudest saadud järjestikuseid andmeid. See toimib sarnaselt inimese ajuga, et pakkuda ennustavaid tulemusi.
Korduv närvivõrk näeb välja üsna sarnane traditsioonilise närvivõrguga, välja arvatud see, et neuronitele lisatakse mälu olek. Arvutamine mälu kaasamiseks on lihtne.
Kujutage ette lihtsat mudelit, kus ainult üks neuron toidab andmehulka. Traditsioonilises närvivõrgus toodab mudel väljundi, korrutades sisendi kaalu ja aktiveerimisfunktsiooniga. RNN-i korral saadetakse see väljund mitu korda iseendale tagasi. Me helistame ajasamm aeg, mille jooksul väljundist saab järgmise maatriksi korrutise sisend.
Näiteks alloleval pildil näete, et võrk koosneb ühest neuronist. Võrk arvutab maatriksite korrutuse sisendi ja kaalu vahel ning lisab aktiveerimisfunktsiooniga mittelineaarsuse. Sellest saab t-1 väljund. See väljund on teise maatrikskorrutise sisend.
Allpool kodeerime TensorFlow lihtsa RNN-i, et mõista sammu ja ka väljundi kuju.
Võrk koosneb:
- Neli sisendit
- Kuus neuronit
- 2-kordsed sammud
Võrk toimib nii, nagu on näidatud alloleval pildil.
Võrku nimetatakse korduvaks, kuna see teeb igas aktiveerimisruudus sama toimingu. Võrk arvutas enne aktiveerimisfunktsiooni kasutamist välja sisendite ja eelmise väljundi kaalud.
import numpy as np
import tensorflow as tf
n_inputs = 4
n_neurons = 6
n_timesteps = 2
The data is a sequence of a number from 0 to 9 and divided into three batches of data.
## Data
X_batch = np.array([
[[0, 1, 2, 5], [9, 8, 7, 4]], # Batch 1
[[3, 4, 5, 2], [0, 0, 0, 0]], # Batch 2
[[6, 7, 8, 5], [6, 5, 4, 2]], # Batch 3
])
Saame luua võrgu koos kohahoidjaga andmete, korduva etapi ja väljundi jaoks.
- Määrake andmete kohahoidja
X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])
siin:
- Puudub: teadmata ja vastab partii suurusele
- n_timesteps: mitu korda võrk saadab väljundi neuronile tagasi
- n_inputs: sisendite arv partii kohta
- Määratlege korduv võrk
Nagu ülaltoodud pildil mainitud, koosneb võrk 6 neuronist. Võrk arvutab kahe punktiga korrutise:
- Sisendandmed esimese kaalukomplektiga (st 6: võrdne neuronite arvuga)
- Eelmine väljund teise kaalukomplektiga (st 6: vastab väljundi arvule)
Pange tähele, et esimese edasisuunamise ajal on eelmise väljundi väärtused võrdsed nullidega, kuna meil pole ühtegi väärtust saadaval.
RNN-i koostamise objekt on tf.contrib.rnn.BasicRNNCell argumendiga num_units, mis määrab sisendi arvu
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
Nüüd, kui võrk on määratletud, saate väljundid ja olekud arvutada
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
See objekt kasutab sisemist tsüklit maatriksite korrutamiseks sobiva arvu kordi.
Pange tähele, et korduv neuron on kõigi eelmiste ajaetappide sisendite funktsioon. Nii loob võrk oma mälu. Eelmise aja teave võib levida ka tulevikus. See on korduva närvivõrgu võlu
## Define the shape of the tensor
X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])
## Define the network
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
init = tf.global_variables_initializer()
init = tf.global_variables_initializer()
with tf.Session() as sess:
init.run()
outputs_val = outputs.eval(feed_dict={X: X_batch})
print(states.eval(feed_dict={X: X_batch}))
[[ 0.38941205 -0.9980438 0.99750966 0.7892596 0.9978241 0.9999997 ]
[ 0.61096436 0.7255889 0.82977575 -0.88226104 0.29261455 -0.15597084]
[ 0.62091285 -0.87023467 0.99729395 -0.58261937 0.9811445 0.99969864]]
Selgituseks trükite eelmise oleku väärtused. Ülaltoodud väljund näitab viimase oleku väljundit. Nüüd printige kõik väljundid, võite märgata, et olekud on iga partii eelmine väljund. See tähendab, et eelmine väljund sisaldab teavet kogu jada kohta.e
print(outputs_val)
print(outputs_val.shape)
[[[-0.75934666 -0.99537754 0.9735819 -0.9722234 -0.14234993
-0.9984044 ]
[ 0.99975264 -0.9983206 0.9999993 -1. -0.9997506
-1. ]]
[[ 0.97486496 -0.98773265 0.9969686 -0.99950117 -0.7092863
-0.99998885]
[ 0.9326837 0.2673438 0.2808514 -0.7535883 -0.43337247
0.5700631 ]]
[[ 0.99628735 -0.9998728 0.99999213 -0.99999976 -0.9884324
-1. ]
[ 0.99962527 -0.9467421 0.9997403 -0.99999714 -0.99929446
-0.9999795 ]]]
(3, 2, 6)
Väljundi kuju on (3, 2, 6):
- 3: partiide arv
- 2: ajasammu number
- 6: neuronite arv
Korduva närvivõrgu optimeerimine on identne traditsioonilise närvivõrguga. Selle korduva närvivõrgu õpetuse järgmises osas näete üksikasjalikumalt, kuidas kodeerida optimeerimist.
RNN-i rakendused
RNN-il on mitu kasutusotstarvet, eriti kui tegemist on tuleviku ennustamisega. Finantssektoris võib RNN olla abiks aktsiahindade või aktsiaturu suuna märgi (st positiivse või negatiivse) ennustamisel.
RNN on kasulik autonoomse auto jaoks, kuna see võib sõiduki trajektoori ette nägedes vältida autoõnnetust.
RNN-i kasutatakse laialdaselt tekstianalüüsis, piltide pealdises, tundeanalüüsis ja masintõlkes. Näiteks saab kasutada filmiarvustust, et mõista tunnet, mida vaataja pärast filmi vaatamist koges. Selle ülesande automatiseerimine on väga kasulik, kui filmifirmal pole piisavalt aega arvustuste ülevaatamiseks, sildistamiseks, koondamiseks ja analüüsimiseks. Masin suudab seda tööd teha suurema täpsusega.
RNN piirangud
Teoreetiliselt peaks RNN edastama teavet kuni ajani. Siiski on üsna keeruline kogu seda teavet levitada, kui ajasamm on liiga pikk. Kui võrgul on liiga palju sügavaid kihte, muutub see treenimatuks. Seda probleemi nimetatakse: kaduva gradiendi probleem. Kui mäletate, värskendab närvivõrk kaalu gradiendi laskumisalgoritmi abil. Gradiendid muutuvad väiksemaks, kui võrk liigub madalamatele kihtidele.
Kokkuvõtteks võib öelda, et gradiendid jäävad konstantseks, mis tähendab, et parandamiseks pole ruumi. Mudel õpib gradiendi muutusest; see muudatus mõjutab võrgu väljundit. Kui aga gradiendi erinevus on liiga väike (st kaalud veidi muutuvad), ei saa võrk midagi õppida ja seega ka väljund. Seetõttu ei saa võrk, mis seisab silmitsi kaduva gradiendi probleemiga, läheneda hea lahenduse poole.
LSTM-i täiustamine
RNN-i võimaliku kaduva gradiendi probleemi lahendamiseks täiustasid kolm teadlast Hochreiter, Schmidhuber ja Bengio RNN-i arhitektuuriga, mida nimetatakse pikaks lühiajaliseks mäluks (LSTM). Lühidalt öeldes annab LSMT võrgule asjakohast teavet varasemate aegade kohta. Masin kasutab teabe valimiseks ja hilisemasse aega tagasi viimiseks paremat arhitektuuri.
LSTM-i arhitektuur on saadaval TensorFlow's, tf.contrib.rnn.LSTMCell. LSTM on õpetuse ulatusest väljas. Võite pöörduda ametniku poole dokumentatsioon lisateavet
RNN aegreas
Selles TensorFlow RNN õpetuses kasutate aegridade andmetega RNN-i. Aegread sõltuvad eelmisest ajast, mis tähendab, et varasemad väärtused sisaldavad asjakohast teavet, millest võrk saab õppida. Aegridade prognoosimise idee seisneb selles, et hinnata rea tulevast väärtust, oletame, et aktsia hind, temperatuur, SKT ja nii edasi.
Andmete ettevalmistamine Kerase RNN-i ja aegridade jaoks võib olla veidi keeruline. Esiteks on eesmärk ennustada seeria järgmist väärtust, mis tähendab, et kasutate mineviku teavet, et hinnata väärtust t + 1 juures. Silt võrdub sisendjadaga ja nihutatakse ühe perioodi võrra ettepoole. Teiseks on sisendi arvuks seatud 1, st üks vaatlus korraga. Lõpuks on ajasamm võrdne arvväärtuse jadaga. Näiteks kui määrate aja sammuks 10, tagastab sisestusjada kümme järjestikust korda.
Vaadake allolevat graafikut, vasakul oleme kujutanud aegridade andmeid ja paremal fiktiivset sisendjada. Loote funktsiooni, mis tagastab iga päeva kohta juhusliku väärtusega andmestiku ajavahemikus jaanuarist 2001 kuni detsembrini 2016
# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
def create_ts(start = '2001', n = 201, freq = 'M'):
rng = pd.date_range(start=start, periods=n, freq=freq)
ts = pd.Series(np.random.uniform(-18, 18, size=len(rng)), rng).cumsum()
return ts
ts= create_ts(start = '2001', n = 192, freq = 'M')
ts.tail(5)
Väljund
2016-08-31 -93.459631 2016-09-30 -95.264791 2016-10-31 -95.551935 2016-11-30 -105.879611 2016-12-31 -123.729319 Freq: M, dtype: float64
ts = create_ts(start = '2001', n = 222)
# Left
plt.figure(figsize=(11,4))
plt.subplot(121)
plt.plot(ts.index, ts)
plt.plot(ts.index[90:100], ts[90:100], "b-", linewidth=3, label="A training instance")
plt.title("A time series (generated)", fontsize=14)
# Right
plt.subplot(122)
plt.title("A training instance", fontsize=14)
plt.plot(ts.index[90:100], ts[90:100], "b-", markersize=8, label="instance")
plt.plot(ts.index[91:101], ts[91:101], "bo", markersize=10, label="target", markerfacecolor='red')
plt.legend(loc="upper left")
plt.xlabel("Time")
plt.show()
Graafiku parempoolne osa näitab kõiki seeriaid. See algas 2001. aastast ja lõpeb 2019. aastal. Kõiki võrgus olevaid andmeid pole mõtet toita, selle asemel tuleb luua andmepakett, mille pikkus on võrdne ajasammuga. See partii on muutuja X. Muutuja Y on sama, mis X, kuid nihutatud ühe perioodi võrra (st soovite prognoosida t+1).
Mõlemad vektorid on sama pikkusega. Näete seda ülaltoodud graafiku paremas osas. Rida tähistab X-sisendi kümmet väärtust, punased punktid aga kümmet sildi Y väärtust. Pange tähele, et silt algab ühe punkti võrra enne X-i ja lõpeb ühe punktiga pärast seda.
Koostage RNN, et ennustada TensorFlow aegrida
Nüüd on sellel RNN-i koolitusel aeg luua oma esimene RNN, et ennustada ülaltoodud seeriat. Mudeli jaoks peate määrama mõned hüperparameetrid (mudeli parameetrid, st neuronite arv jne):
- Sisendite arv: 1
- Ajasamm (aknad aegridades): 10
- Neuronite arv: 120
- Väljundite arv: 1
Teie võrk õpib 10-päevasest järjestusest ja sisaldab 120 korduvat neuronit. Toidate mudelit ühe sisendiga, st ühe päevaga. Muutke vabalt väärtusi, et näha, kas mudel on paranenud.
Enne mudeli koostamist peate andmestiku jagama rongikomplektiks ja katsekomplektiks. Täielikus andmekogumis on 222 andmepunkti; kasutate esimest 201 punkti mudeli koolitamiseks ja viimast 21 punkti oma mudeli testimiseks.
Pärast rongi- ja katsekomplekti määratlemist peate looma partiisid sisaldava objekti. Selles partiides on teil X väärtused ja Y väärtused. Pidage meeles, et X väärtused on ühe perioodi hilinemisega. Seetõttu kasutate esimest 200 vaatlust ja ajasamm on 10. Objekt X_batches peaks sisaldama 20 partiid suurusega 10*1. Objektil y_batches on sama kuju kui objektil X_batches, kuid üks periood ees.
Step 1) Looge rong ja katsetage
Kõigepealt teisendate seeria a-ks tuim massiiv; Seejärel määrate aknad (st aja arv, millest võrk õpib), sisendi, väljundi arvu ja rongikogumi suuruse, nagu on näidatud allolevas TensorFlow RNN näites.
series = np.array(ts) n_windows = 20 n_input = 1 n_output = 1 size_train = 201
Pärast seda jagate massiivi lihtsalt kaheks andmekogumiks.
## Split data train = series[:size_train] test = series[size_train:] print(train.shape, test.shape) (201,) (21,)
Step 2) Looge funktsioon X_batches ja y_batches tagastamiseks
Selle lihtsamaks muutmiseks saate luua funktsiooni, mis tagastab kaks erinevat massiivi, ühe X_batches ja teise y_batches jaoks.
Kirjutame partiide koostamiseks funktsiooni RNN TensorFlow.
Pange tähele, et X partiid on ühe perioodi võrra maha jäänud (võtame väärtuse t-1). Funktsiooni väljund peaks olema kolmemõõtmeline. Esimene mõõde võrdub partiide arvuga, teine akende suurusega ja viimane sisendi arvuga.
Keeruline osa on andmepunktide õige valimine. X andmepunktide jaoks valite vaatlused vahemikus t = 1 kuni t = 200, samas kui Y andmepunkti puhul tagastate vaatlused vahemikus t = 2 kuni 201. Kui teil on õiged andmepunktid, on lihtne ümber kujundada sari.
Objekti koos partiidega konstrueerimiseks peate jagama andmestiku kümneks võrdse pikkusega partiiks (st 20). Võite kasutada ümberkujundamise meetodit ja edastada -1, nii et seeria sarnaneks partii suurusega. Väärtus 20 on vaatluste arv partii kohta ja 1 on sisendi arv.
Peate tegema sama sammu, kuid sildi jaoks.
Pange tähele, et peate andmeid nihutama nii palju kordi, kui palju soovite prognoosida. Näiteks kui soovite ennustada ühe aja ette, nihutage seeriat 1 võrra. Kui soovite prognoosida kahte päeva, nihutage andmeid 2 võrra.
x_data = train[:size_train-1]: Select all the training instance minus one day
X_batches = x_data.reshape(-1, windows, input): create the right shape for the batch e.g (10, 20, 1)
def create_batches(df, windows, input, output):
## Create X
x_data = train[:size_train-1] # Select the data
X_batches = x_data.reshape(-1, windows, input) # Reshape the data
## Create y
y_data = train[n_output:size_train]
y_batches = y_data.reshape(-1, windows, output)
return X_batches, y_batches
Nüüd, kui funktsioon on määratletud, saate seda kutsuda, et luua partiid, nagu on näidatud allolevas RNN-i näites.
X_batches, y_batches = create_batches(df = train,
windows = n_windows,
input = n_input,
output = n_output)
Mõõtmete õigsuses veendumiseks saate kuju printida.
print(X_batches.shape, y_batches.shape) (10, 20, 1) (10, 20, 1)
Peate looma testikomplekti ainult ühe andmekogumi ja 20 vaatlusega.
Pange tähele, et prognoosite päevade kaupa, tähendab see, et teine prognoositav väärtus põhineb testandmestiku esimese päeva tegelikul väärtusel (t+1). Tegelikult selgub tegelik väärtus.
Kui soovite prognoosida t+2 (st kaks päeva ette), peate kasutama prognoositavat väärtust t+1; kui kavatsete ennustada t+3 (kolm päeva ette), peate kasutama ennustatud väärtusi t+1 ja t+2. On mõistlik, et t+n päeva ette on raske täpselt ennustada.
X_test, y_test = create_batches(df = test, windows = 20,input = 1, output = 1) print(X_test.shape, y_test.shape) (10, 20, 1) (10, 20, 1)
Olgu, teie partii suurus on valmis, saate luua RNN-i arhitektuuri. Pidage meeles, et teil on 120 korduvat neuronit.
Step 3) Ehitage mudel
Mudeli loomiseks peate määratlema kolm osa:
- Muutuja tensoritega
- RNN
- Kaotus ja optimeerimine
Step 3.1) Muutujad
Peate määrama sobiva kujuga muutujad X ja y. See samm on triviaalne. Tensoril on sama mõõde kui objektidel X_batches ja y_batches.
Näiteks tensor X on kohatäide (Vaadake õpetust Sissejuhatus Tensorivoog et värskendada oma meelt muutuja deklaratsiooni osas) on kolm mõõdet:
- Märkus: partii suurus
- n_windows: akende pikkus. st kordade arv, mil mudel vaatab tagasi
- n_input: sisendi arv
Tulemuseks on:
tf.placeholder(tf.float32, [None, n_windows, n_input])
## 1. Construct the tensors X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output])
Step 3.2) Looge RNN
Selle RNN TensorFlow näite teises osas peate määratlema võrgu arhitektuuri. Nagu varemgi, kasutate TensorFlow hindaja objekti BasicRNNCell ja dynamic_rnn.
## 2. create the model basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
Järgmine osa on pisut keerulisem, kuid võimaldab kiiremat arvutamist. Peate tööväljundi teisendama tihedaks kihiks ja seejärel teisendama selle uuesti sisendiga samasuguseks mõõtmeks.
stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])
Step 3.3) Loo kaotus ja optimeerimine
Mudeli optimeerimine sõltub teie täidetavast ülesandest. Eelmises õpetuses teemal CNN, teie eesmärk oli pilte klassifitseerida, selles RNN-i õpetuses on eesmärk pisut erinev. Teil palutakse teha ennustus pideva muutuja kohta, võrreldes klassiga.
See erinevus on oluline, kuna see muudab optimeerimisprobleemi. Pideva muutuja optimeerimisprobleem on keskmise ruutvea minimeerimine. Nende mõõdikute koostamiseks TF-is saate kasutada:
- tf.reduce_sum(tf.ruut(väljundid – y))
Ülejäänud RNN-kood on sama, mis varem; kasutate kadude (st MSE) vähendamiseks Adami optimeerijat:
- tf.train.AdamOptimizer(learning_rate=learning_rate)
- optimeerija.minimeerima(kadu)
See on kõik, saate kõik kokku pakkida ja teie modell on treenimiseks valmis.
tf.reset_default_graph() r_neuron = 120 ## 1. Construct the tensors X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output]) ## 2. create the model basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32) stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output]) ## 3. Loss + optimization learning_rate = 0.001 loss = tf.reduce_sum(tf.square(outputs - y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) training_op = optimizer.minimize(loss) init = tf.global_variables_initializer()
Treenite mudelit 1500 epohhi abil ja prindite kadu iga 150 iteratsiooni järel. Kui mudel on koolitatud, hindate mudelit testikomplektis ja loote ennustusi sisaldava objekti, nagu on näidatud allolevas korduva närvivõrgu näites.
iteration = 1500
with tf.Session() as sess:
init.run()
for iters in range(iteration):
sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
if iters % 150 == 0:
mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
print(iters, "\tMSE:", mse)
y_pred = sess.run(outputs, feed_dict={X: X_test})
0 MSE: 502893.34
150 MSE: 13839.129
300 MSE: 3964.835
450 MSE: 2619.885
600 MSE: 2418.772
750 MSE: 2110.5923
900 MSE: 1887.9644
1050 MSE: 1747.1377
1200 MSE: 1556.3398
1350 MSE: 1384.6113
Lõpuks saate selles RNN-i süvaõppe õpetuses joonistada seeria tegeliku väärtuse prognoositud väärtusega. Kui teie mudelit korrigeeritakse, tuleks prognoositud väärtused lisada tegelikele väärtustele.
Nagu näete, on mudelil arenguruumi. Teie ülesanne on muuta hüperparameetreid, nagu aknad, korduvate neuronite arvu partii suurust.
plt.title("Forecast vs Actual", fontsize=14)
plt.plot(pd.Series(np.ravel(y_test)), "bo", markersize=8, label="Actual", color='green')
plt.plot(pd.Series(np.ravel(y_pred)), "r.", markersize=8, label="Forecast", color='red')
plt.legend(loc="lower left")
plt.xlabel("Time")
plt.show()
kokkuvõte
Korduv närvivõrk on tugev arhitektuur aegridade või tekstianalüüsiga tegelemiseks. Eelmise oleku väljundiks on tagasiside, et säilitada võrgu mälu ajas või sõnade järjestuses.
TensorFlow's saate aegridade jaoks TensorFlow korduva närvivõrgu treenimiseks kasutada järgmisi koode:
Mudeli parameetrid
n_windows = 20 n_input = 1 n_output = 1 size_train = 201
Määratlege mudel
X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output]) basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32) stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])
Koostage optimeerimine
learning_rate = 0.001 loss = tf.reduce_sum(tf.square(outputs - y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) training_op = optimizer.minimize(loss)
Treeni modelli
init = tf.global_variables_initializer()
iteration = 1500
with tf.Session() as sess:
init.run()
for iters in range(iteration):
sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
if iters % 150 == 0:
mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
print(iters, "\tMSE:", mse)
y_pred = sess.run(outputs, feed_dict={X: X_test})
