In [9]:

    

# Data: time-serie data from smartwatch or smartwatch data
# %matplotlib inline # for plt.show()
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Data reading
# The smartwatch historical/time-seris data to visualize
# data_path = 'data/smartwatch_data/experimental_data_analysis/Basis_Watch_Data.csv'
# data_path = 'data/financial_data/USD_INR.csv'
data_path = 'data/bike_data/hour.csv'
data = pd.read_csv(data_path)

# Data: cleaning
# Getting rid of NaN
data = data.fillna(value=0.0)

# Showing the data file csv or comma separated value
data[:10]


    

    
Out[9]:







  

    

      

      
instant
      
dteday
      
season
      
yr
      
mnth
      
hr
      
holiday
      
weekday
      
workingday
      
weathersit
      
temp
      
atemp
      
hum
      
windspeed
      
casual
      
registered
      
cnt
    
  
  

    

      
0
      
1
      
2011-01-01
      
1
      
0
      
1
      
0
      
0
      
6
      
0
      
1
      
0.24
      
0.2879
      
0.81
      
0.0000
      
3
      
13
      
16
    
    

      
1
      
2
      
2011-01-01
      
1
      
0
      
1
      
1
      
0
      
6
      
0
      
1
      
0.22
      
0.2727
      
0.80
      
0.0000
      
8
      
32
      
40
    
    

      
2
      
3
      
2011-01-01
      
1
      
0
      
1
      
2
      
0
      
6
      
0
      
1
      
0.22
      
0.2727
      
0.80
      
0.0000
      
5
      
27
      
32
    
    

      
3
      
4
      
2011-01-01
      
1
      
0
      
1
      
3
      
0
      
6
      
0
      
1
      
0.24
      
0.2879
      
0.75
      
0.0000
      
3
      
10
      
13
    
    

      
4
      
5
      
2011-01-01
      
1
      
0
      
1
      
4
      
0
      
6
      
0
      
1
      
0.24
      
0.2879
      
0.75
      
0.0000
      
0
      
1
      
1
    
    

      
5
      
6
      
2011-01-01
      
1
      
0
      
1
      
5
      
0
      
6
      
0
      
2
      
0.24
      
0.2576
      
0.75
      
0.0896
      
0
      
1
      
1
    
    

      
6
      
7
      
2011-01-01
      
1
      
0
      
1
      
6
      
0
      
6
      
0
      
1
      
0.22
      
0.2727
      
0.80
      
0.0000
      
2
      
0
      
2
    
    

      
7
      
8
      
2011-01-01
      
1
      
0
      
1
      
7
      
0
      
6
      
0
      
1
      
0.20
      
0.2576
      
0.86
      
0.0000
      
1
      
2
      
3
    
    

      
8
      
9
      
2011-01-01
      
1
      
0
      
1
      
8
      
0
      
6
      
0
      
1
      
0.24
      
0.2879
      
0.75
      
0.0000
      
1
      
7
      
8
    
    

      
9
      
10
      
2011-01-01
      
1
      
0
      
1
      
9
      
0
      
6
      
0
      
1
      
0.32
      
0.3485
      
0.76
      
0.0000
      
8
      
6
      
14
    
  

In [10]:

    

# # Plotting the smartwatch data before scaling/batch normalization
# data[:10000]['Price'].plot()
data[: 10].plot()
plt.legend()
plt.show()


    

In [11]:

    

data_array = np.array(data)
data_array.shape, data_array.dtype
data_main = np.array(data_array[:, -1:], dtype=float)
data_main.shape, data_main.dtype

plt.plot(data_main[:100])
plt.show()


    

In [12]:

    

mean = np.mean(data_main, axis=0)
std = np.std(data_main, axis=0)
std.shape, mean.shape, std.dtype, mean.dtype

data_norm = (data_main - mean) / std
plt.plot(data_norm[:100])
plt.show()
data_norm.mean(), data_norm.std(), data_norm.var(), data_norm.shape, data_norm.dtype


    

    













    
Out[12]:





(-1.0548364452851478e-16, 1.0, 1.0, (17379, 1), dtype('float64'))

In [13]:

    

train_data = data_norm[:16000] # the last dim/variable/feature
test_data = data_norm[16000:] # the last dim/variable/feature
train_data.shape, test_data.shape
X_train = train_data[0:15999]
Y_train = train_data[1:16000]
X_train.shape, Y_train.shape

plt.plot(X_train[:100])
plt.plot(Y_train[:100])
plt.show()


    

In [14]:

    

X_valid = test_data[0:1378] 
Y_valid = test_data[1:1379]
X_valid.shape, Y_valid.shape
plt.plot(X_valid[:100])
plt.plot(Y_valid[:100])
plt.show()


    

In [15]:

    

# Model or Network
import impl.layer as l
from impl.loss import *

class GRU:
    def __init__(self, D, H):
        self.D = D
        self.H = H
        self.losses = {'train':[], 'smooth train':[], 'valid': []}
        
        # Model params
        Z = H + D
        low_Z, high_Z = (-1. / np.sqrt(Z / 2.)), (1. / np.sqrt(Z / 2.))
        low_H, high_H = (-1. / np.sqrt(H / 2.)), (1. / np.sqrt(H / 2.))
        # low, high = (-1.0), (+1.0)
        # low, high = (-0.5), (+0.5)
        m = dict(
            # Wz=np.random.randn(Z, H) / np.sqrt(Z / 2.),
            # Wr=np.random.randn(Z, H) / np.sqrt(Z / 2.),
            # Wh=np.random.randn(Z, H) / np.sqrt(Z / 2.),
            # Wy=np.random.randn(H, D) / np.sqrt(H / 2.),
            Wz=np.random.uniform(size=(Z, H), low=low_Z, high=high_Z),
            Wr=np.random.uniform(size=(Z, H), low=low_Z, high=high_Z),
            Wh=np.random.uniform(size=(Z, H), low=low_Z, high=high_Z),
            Wy=np.random.uniform(size=(H, D), low=low_H, high=high_H),
            bz=np.zeros((1, H)),
            br=np.zeros((1, H)),
            bh=np.zeros((1, H)),
            by=np.zeros((1, D))
        )
        self.model = m
        
    def initial_state(self):
        return np.zeros((1, self.H))

    def forward(self, X, h, m):
        Wz, Wr, Wh, Wy = m['Wz'], m['Wr'], m['Wh'], m['Wy']
        bz, br, bh, by = m['bz'], m['br'], m['bh'], m['by']

        X_in = X.copy()
        h_in = h.copy()

        X = np.column_stack((h_in, X_in))

        hz, hz_cache = l.fc_forward(X, Wz, bz)
        hz, hz_sigm_cache = l.sigmoid_forward(hz)

        hr, hr_cache = l.fc_forward(X, Wr, br)
        hr, hr_sigm_cache = l.sigmoid_forward(hr)

        X = np.column_stack((hr * h_in, X_in))
        
        hh, hh_cache = l.fc_forward(X, Wh, bh)
        hh, hh_tanh_cache = l.tanh_forward(hh)

        # h = (1. - hz) * h_old + hz * hh
        # or
        h = ((1. - hz) * h_in) + (hz * hh)
        # or
        # h = h_in + hz (hh - h_in)

        y, y_cache = l.fc_forward(h, Wy, by)
        
        cache = (h_in, hz, hz_cache, hz_sigm_cache, hr, hr_cache, hr_sigm_cache, hh, hh_cache, hh_tanh_cache, 
                 y_cache)

        return y, h, cache

    def backward(self, dy, dh, cache):
        h_in, hz, hz_cache, hz_sigm_cache, hr, hr_cache, hr_sigm_cache, hh, hh_cache, hh_tanh_cache, y_cache = cache
        
        dh_out = dh.copy()

        dh, dWy, dby = l.fc_backward(dy, y_cache)
        dh += dh_out

        dh_in1 = (1. - hz) * dh
        dhh = hz * dh
        dhz = (hh * dh) - (h_in * dh)
        # or
        # dhz = (hh - h_in) * dh

        dhh = l.tanh_backward(dhh, hh_tanh_cache)
        dXh, dWh, dbh = l.fc_backward(dhh, hh_cache)

        dh = dXh[:, :self.H]
        dX_in2 = dXh[:, self.H:]
        dh_in2 = hr * dh

        dhr = h_in * dh
        dhr = l.sigmoid_backward(dhr, hr_sigm_cache)
        dXr, dWr, dbr = l.fc_backward(dhr, hr_cache)

        dhz = l.sigmoid_backward(dhz, hz_sigm_cache)
        dXz, dWz, dbz = l.fc_backward(dhz, hz_cache)

        dX = dXr + dXz
        dh_in3 = dX[:, :self.H]
        dX_in1 = dX[:, self.H:]

        dh = dh_in1 + dh_in2 + dh_in3
        dX = dX_in1 + dX_in2

        grad = dict(Wz=dWz, Wr=dWr, Wh=dWh, Wy=dWy, bz=dbz, br=dbr, bh=dbh, by=dby)
        
        return dX, dh, grad

    def train_forward(self, X_train, h):
        ys, fc_caches = [], []

        for X in X_train:
            X = X.reshape(1, -1) # X_1xn
            y, h, fc_cache = self.forward(X, h, self.model)
            fc_caches.append(fc_cache)
            ys.append(y)
        
        ys = np.array(ys, dtype=float).reshape(len(ys), -1) # ys_txn instead of ys_tx1xn
        caches = fc_caches
        
        return ys, caches
                                
    def loss_function(self, y_pred, y_train):
        loss, dys = 0.0, []

        for y, Y in zip(y_pred, y_train):
            loss += l2_regression(y_pred=y, y_train=Y)
            dy = dl2_regression(y_pred=y, y_train=Y)
            dys.append(dy)
            
        return loss, dys
    
    def train_backward(self, dys, caches):
        fc_caches = caches
        
        dh = np.zeros((1, self.H)) 
        grad = {key: np.zeros_like(val) for key, val in self.model.items()}
        grads= {key: np.zeros_like(val) for key, val in self.model.items()}

        for t in reversed(range(len(dys))):
            dy = dys[t].reshape(1, -1) # dy_1xn
            dX, dh, grad = self.backward(dy, dh, fc_caches[t])
            for key in grad.keys():
                grads[key] += grad[key]
                
        return dX, grads # TODO: dX is not used but this is a REMINDER that it exists!
    
    def test(self, X_seed, h, size):
        ys = []
        X = X_seed.reshape(1, -1)
        for _ in range(size):
            y, h, _ = self.forward(X, h, self.model)
            X = y.copy() # previous out for the next input for prediction
            ys.append(y) # list array
        
        ys = np.array(ys, dtype=float).reshape(len(ys), -1) # ys_txn instead of ys_tx1xn
        return ys


    

In [16]:

    

def get_minibatch(X, y, minibatch_size, shuffle):
    minibatches = []

    # for i in range(0, X.shape[0] - minibatch_size + 1, 1):
    for i in range(0, X.shape[0], minibatch_size):
        X_mini = X[i:(i + minibatch_size)]
        y_mini = y[i:(i + minibatch_size)]
        minibatches.append((X_mini, y_mini))

    return minibatches

def adam_rnn(nn, XY_train, XY_valid, alpha, mb_size, n_iter, print_after):
    X_train, y_train = XY_train
    X_valid, y_valid = XY_valid

    # Momentum
    M= {key: np.zeros_like(val) for key, val in nn.model.items()}
    R= {key: np.zeros_like(val) for key, val in nn.model.items()}
    
    # Learning decay: suggested by Justin Jhonson in Standford
    beta1 = .9
    beta2 = .99
    state = nn.initial_state()
    smooth_loss = 1.
    minibatches = get_minibatch(X_train, y_train, mb_size, shuffle=False)
    
    # Epochs: iterating through the whole data
    for iter in range(1, n_iter + 1):
        
        # Minibatches
        for idx in range(len(minibatches)):
            
            # Train the model
            X_mini, y_mini = minibatches[idx]
            ys, caches = nn.train_forward(X_mini, state)
            loss, dys = nn.loss_function(y_pred=ys, y_train=y_mini) #, alpha=alpha
            _, grads = nn.train_backward(dys, caches)
            nn.losses['train'].append(loss)
            smooth_loss = (0.999 * smooth_loss) + (0.001 * loss)
            nn.losses['smooth train'].append(smooth_loss)
            
            # Update the model
            for key in grads.keys(): #key, value: items
                M[key] = l.exp_running_avg(M[key], grads[key], beta1)
                R[key] = l.exp_running_avg(R[key], grads[key]**2, beta2)
                m_k_hat = M[key] / (1. - (beta1** iter))
                r_k_hat = R[key] / (1. - (beta2** iter))
                nn.model[key] -= alpha * m_k_hat / (np.sqrt(r_k_hat) + l.eps)

            # Validate the model (by testing)
            ys = nn.test(X_seed=X_valid[0], h=state, size=X_valid.shape[0]) # ys_tx1xn
            valid_loss, _ = nn.loss_function(y_pred=ys, y_train=Y_valid) #, alpha=alpha
            nn.losses['valid'].append(valid_loss)

        # Print the model loss/ error
        if iter % print_after == 0:
            print('Iter-{}, train loss: {:.8f}, valid loss: {:.8f}'.format(iter, loss, valid_loss))

    return nn


    

In [17]:

    

# Hyper-parameters
time_step = 128 # minibatch size: 32, 64, 128, or 256 Cache
n_iter = 200 # epochs
alpha = 1e-4 # learning_rate: 1e-3, 5e-4, 1e-4 - default choices
print_after = 1 # print training loss, valid, and test
num_hidden_units = 64 # num_hidden_units in hidden layer
num_input_units = X_train.shape[1] # X_txn: noise given by using all possible channels/ features

# Build the network and learning it or optimizing it using SGD
# def adam_rnn(nn, X_train, y_train, alpha=0.001, mb_size=256, n_iter=2000, print_after=100):
net = GRU(D=num_input_units, H=num_hidden_units) 

# Start learning using BP-SGD-ADAM
adam_rnn(nn=net, XY_train=(X_train, Y_train), XY_valid=(X_valid, Y_valid), alpha=alpha, mb_size=time_step,
         n_iter=n_iter, print_after=print_after)


    

    




Iter-1, train loss: 43.47683044, valid loss: 632.84644934
Iter-2, train loss: 39.61085030, valid loss: 632.62086813
Iter-3, train loss: 36.80123505, valid loss: 632.66455489
Iter-4, train loss: 34.62201390, valid loss: 632.89639025
Iter-5, train loss: 32.92987360, valid loss: 633.36451991
Iter-6, train loss: 31.54376765, valid loss: 634.15680111
Iter-7, train loss: 30.33311595, valid loss: 635.26678925
Iter-8, train loss: 29.23601853, valid loss: 636.62953474
Iter-9, train loss: 28.21959077, valid loss: 638.17891785
Iter-10, train loss: 27.26036659, valid loss: 639.88850355
Iter-11, train loss: 26.33781994, valid loss: 641.79848739
Iter-12, train loss: 25.43003501, valid loss: 644.05192775
Iter-13, train loss: 24.50806627, valid loss: 647.04639789
Iter-14, train loss: 23.52529755, valid loss: 651.87507723
Iter-15, train loss: 22.39440902, valid loss: 662.11165900
Iter-16, train loss: 20.96139126, valid loss: 695.24171210
Iter-17, train loss: 19.31658189, valid loss: 816.54085276
Iter-18, train loss: 18.15093860, valid loss: 919.73970950
Iter-19, train loss: 17.44173793, valid loss: 952.67046857
Iter-20, train loss: 16.92400317, valid loss: 993.92056488
Iter-21, train loss: 16.51163528, valid loss: 1033.30707212
Iter-22, train loss: 16.16828146, valid loss: 1065.83613361
Iter-23, train loss: 15.86974788, valid loss: 1092.09845858
Iter-24, train loss: 15.59239767, valid loss: 1114.34174152
Iter-25, train loss: 15.31510288, valid loss: 1133.66064841
Iter-26, train loss: 15.02910597, valid loss: 1151.38158258
Iter-27, train loss: 14.73303269, valid loss: 1168.82775858
Iter-28, train loss: 14.42936567, valid loss: 1186.43758306
Iter-29, train loss: 14.12276277, valid loss: 1204.13913637
Iter-30, train loss: 13.81823564, valid loss: 1222.01057456
Iter-31, train loss: 13.51912965, valid loss: 1240.77615654
Iter-32, train loss: 13.22603296, valid loss: 1261.87354819
Iter-33, train loss: 12.93757082, valid loss: 1286.99852197
Iter-34, train loss: 12.65221665, valid loss: 1317.25244959
Iter-35, train loss: 12.36874948, valid loss: 1352.56798835
Iter-36, train loss: 12.08546015, valid loss: 1391.97220760
Iter-37, train loss: 11.80003291, valid loss: 1434.24059682
Iter-38, train loss: 11.51003121, valid loss: 1478.13073248
Iter-39, train loss: 11.21333127, valid loss: 1522.30897240
Iter-40, train loss: 10.90842850, valid loss: 1565.29494489
Iter-41, train loss: 10.59464418, valid loss: 1605.49068673
Iter-42, train loss: 10.27221542, valid loss: 1641.26062387
Iter-43, train loss: 9.94224392, valid loss: 1671.00974735
Iter-44, train loss: 9.60649557, valid loss: 1693.22038955
Iter-45, train loss: 9.26708654, valid loss: 1706.44058904
Iter-46, train loss: 8.92615412, valid loss: 1709.25182200
Iter-47, train loss: 8.58565847, valid loss: 1700.26389704
Iter-48, train loss: 8.24745307, valid loss: 1678.18936618
Iter-49, train loss: 7.91366177, valid loss: 1642.04070540
Iter-50, train loss: 7.58723021, valid loss: 1591.46390580
Iter-51, train loss: 7.27237169, valid loss: 1527.15668440
Iter-52, train loss: 6.97460161, valid loss: 1451.21951370
Iter-53, train loss: 6.70017219, valid loss: 1367.21108097
Iter-54, train loss: 6.45491138, valid loss: 1279.72414689
Iter-55, train loss: 6.24269188, valid loss: 1193.54416188
Iter-56, train loss: 6.06404560, valid loss: 1112.83764439
Iter-57, train loss: 5.91568738, valid loss: 1058.76091133
Iter-58, train loss: 5.79145655, valid loss: 1173.35370708
Iter-59, train loss: 5.68427062, valid loss: 1248.77816536
Iter-60, train loss: 5.58797267, valid loss: 1260.22484285
Iter-61, train loss: 5.49825008, valid loss: 1279.52327173
Iter-62, train loss: 5.41262777, valid loss: 1295.95314033
Iter-63, train loss: 5.32999312, valid loss: 1250.13493680
Iter-64, train loss: 5.25005289, valid loss: 1233.68977415
Iter-65, train loss: 5.17290388, valid loss: 1109.27278808
Iter-66, train loss: 5.09875035, valid loss: 1250.52037625
Iter-67, train loss: 5.02774390, valid loss: 1499.94764961
Iter-68, train loss: 4.95991090, valid loss: 1165.91392448
Iter-69, train loss: 4.89513405, valid loss: 1238.04061148
Iter-70, train loss: 4.83316040, valid loss: 1281.96934355
Iter-71, train loss: 4.77361782, valid loss: 1213.26584118
Iter-72, train loss: 4.71603092, valid loss: 1223.92682534
Iter-73, train loss: 4.65983367, valid loss: 1105.64978369
Iter-74, train loss: 4.60438183, valid loss: 1350.78747877
Iter-75, train loss: 4.54897606, valid loss: 1146.96793758
Iter-76, train loss: 4.49291578, valid loss: 1197.47536324
Iter-77, train loss: 4.43561084, valid loss: 1265.62113292
Iter-78, train loss: 4.37677022, valid loss: 1224.27656567
Iter-79, train loss: 4.31664261, valid loss: 1350.68643741
Iter-80, train loss: 4.25619873, valid loss: 1327.05203196
Iter-81, train loss: 4.19708455, valid loss: 1300.72443335
Iter-82, train loss: 4.14126057, valid loss: 1313.53773351
Iter-83, train loss: 4.09047226, valid loss: 1396.73610591
Iter-84, train loss: 4.04583871, valid loss: 1440.06582930
Iter-85, train loss: 4.00773493, valid loss: 1391.89170283
Iter-86, train loss: 3.97592497, valid loss: 1352.18925681
Iter-87, train loss: 3.94979821, valid loss: 1330.31940072
Iter-88, train loss: 3.92858913, valid loss: 1379.71571389
Iter-89, train loss: 3.91152945, valid loss: 1259.98472070
Iter-90, train loss: 3.89793116, valid loss: 1327.42797132
Iter-91, train loss: 3.88721814, valid loss: 1225.86404878
Iter-92, train loss: 3.87892685, valid loss: 1351.51083732
Iter-93, train loss: 3.87269194, valid loss: 1404.68505938
Iter-94, train loss: 3.86822672, valid loss: 1368.79973862
Iter-95, train loss: 3.86530422, valid loss: 1438.34872596
Iter-96, train loss: 3.86374113, valid loss: 1341.05477201
Iter-97, train loss: 3.86338539, valid loss: 1345.76847612
Iter-98, train loss: 3.86410713, valid loss: 1469.51939759
Iter-99, train loss: 3.86579236, valid loss: 1349.51207044
Iter-100, train loss: 3.86833881, valid loss: 1319.16764364
Iter-101, train loss: 3.87165319, valid loss: 1388.92518447
Iter-102, train loss: 3.87564958, valid loss: 1194.21444332
Iter-103, train loss: 3.88024845, valid loss: 1385.48668799
Iter-104, train loss: 3.88537614, valid loss: 1482.16317584
Iter-105, train loss: 3.89096459, valid loss: 1390.71139834
Iter-106, train loss: 3.89695121, valid loss: 1393.12864018
Iter-107, train loss: 3.90327882, valid loss: 1269.06694822
Iter-108, train loss: 3.90989553, valid loss: 1634.85349703
Iter-109, train loss: 3.91675462, valid loss: 1539.68810658
Iter-110, train loss: 3.92381431, valid loss: 1545.21567086
Iter-111, train loss: 3.93103752, valid loss: 1558.62590043
Iter-112, train loss: 3.93839156, valid loss: 1569.79352206
Iter-113, train loss: 3.94584775, valid loss: 1569.66962564
Iter-114, train loss: 3.95338105, valid loss: 1583.33789600
Iter-115, train loss: 3.96096964, valid loss: 1607.26592266
Iter-116, train loss: 3.96859457, valid loss: 1612.87183004
Iter-117, train loss: 3.97623931, valid loss: 1637.29619010
Iter-118, train loss: 3.98388942, valid loss: 1657.08384059
Iter-119, train loss: 3.99153214, valid loss: 1658.51870710
Iter-120, train loss: 3.99915615, valid loss: 1655.44087640
Iter-121, train loss: 4.00675117, valid loss: 1633.39433863
Iter-122, train loss: 4.01430777, valid loss: 1327.51073327
Iter-123, train loss: 4.02181708, valid loss: 1653.34934664
Iter-124, train loss: 4.02927059, valid loss: 1619.84423442
Iter-125, train loss: 4.03665999, valid loss: 1627.67716469
Iter-126, train loss: 4.04397701, valid loss: 1104.68933934
Iter-127, train loss: 4.05121328, valid loss: 921.74122073
Iter-128, train loss: 4.05836025, valid loss: 1012.98315415
Iter-129, train loss: 4.06540914, valid loss: 2043.14592282
Iter-130, train loss: 4.07235088, valid loss: 2131.55224009
Iter-131, train loss: 4.07917610, valid loss: 2147.80874669
Iter-132, train loss: 4.08587514, valid loss: 1774.22649849
Iter-133, train loss: 4.09243811, valid loss: 1883.04680603
Iter-134, train loss: 4.09885490, valid loss: 1894.16784929
Iter-135, train loss: 4.10511534, valid loss: 1902.61703935
Iter-136, train loss: 4.11120926, valid loss: 1908.14353211
Iter-137, train loss: 4.11712662, valid loss: 1912.00644370
Iter-138, train loss: 4.12285769, valid loss: 1910.47242542
Iter-139, train loss: 4.12839319, valid loss: 1915.32570429
Iter-140, train loss: 4.13372450, valid loss: 2054.06098315
Iter-141, train loss: 4.13884379, valid loss: 2250.24088678
Iter-142, train loss: 4.14374428, valid loss: 1845.33497981
Iter-143, train loss: 4.14842034, valid loss: 2235.61599885
Iter-144, train loss: 4.15286774, valid loss: 2241.55162875
Iter-145, train loss: 4.15708371, valid loss: 2235.80835361
Iter-146, train loss: 4.16106710, valid loss: 2201.98121363
Iter-147, train loss: 4.16481842, valid loss: 2230.73942156
Iter-148, train loss: 4.16833986, valid loss: 2239.39836785
Iter-149, train loss: 4.17163522, valid loss: 2240.93966906
Iter-150, train loss: 4.17470985, valid loss: 2209.59729562
Iter-151, train loss: 4.17757050, valid loss: 2267.64589623
Iter-152, train loss: 4.18022506, valid loss: 2280.46413132
Iter-153, train loss: 4.18268242, valid loss: 2288.61629074
Iter-154, train loss: 4.18495210, valid loss: 2289.13194186
Iter-155, train loss: 4.18704406, valid loss: 2251.88526133
Iter-156, train loss: 4.18896838, valid loss: 1910.94267962
Iter-157, train loss: 4.19073498, valid loss: 2156.96521821
Iter-158, train loss: 4.19235341, valid loss: 1997.63004263
Iter-159, train loss: 4.19383261, valid loss: 1176.45971907
Iter-160, train loss: 4.19518072, valid loss: 2269.86266559
Iter-161, train loss: 4.19640491, valid loss: 2272.97102416
Iter-162, train loss: 4.19751130, valid loss: 2134.64936273
Iter-163, train loss: 4.19850480, valid loss: 2143.01273002
Iter-164, train loss: 4.19938916, valid loss: 2145.65597961
Iter-165, train loss: 4.20016684, valid loss: 2135.58144931
Iter-166, train loss: 4.20083910, valid loss: 2004.13582985
Iter-167, train loss: 4.20140598, valid loss: 2313.77175398
Iter-168, train loss: 4.20186639, valid loss: 2379.52668340
Iter-169, train loss: 4.20221816, valid loss: 1237.08058183
Iter-170, train loss: 4.20245816, valid loss: 2397.86643503
Iter-171, train loss: 4.20258239, valid loss: 2395.93721792
Iter-172, train loss: 4.20258609, valid loss: 1734.21659133
Iter-173, train loss: 4.20246389, valid loss: 1957.91761685
Iter-174, train loss: 4.20220990, valid loss: 1958.98746462
Iter-175, train loss: 4.20181783, valid loss: 1959.43974698
Iter-176, train loss: 4.20128114, valid loss: 1959.97751073
Iter-177, train loss: 4.20059313, valid loss: 1959.81054735
Iter-178, train loss: 4.19974705, valid loss: 1952.51843446
Iter-179, train loss: 4.19873621, valid loss: 1841.04038866
Iter-180, train loss: 4.19755407, valid loss: 1840.52975811
Iter-181, train loss: 4.19619430, valid loss: 1841.21444734
Iter-182, train loss: 4.19465091, valid loss: 1841.92034956
Iter-183, train loss: 4.19291824, valid loss: 1842.48846093
Iter-184, train loss: 4.19099113, valid loss: 1842.90087234
Iter-185, train loss: 4.18886486, valid loss: 1843.16426086
Iter-186, train loss: 4.18653530, valid loss: 1843.29038250
Iter-187, train loss: 4.18399888, valid loss: 1843.28948024
Iter-188, train loss: 4.18125269, valid loss: 1843.16742029
Iter-189, train loss: 4.17829449, valid loss: 1842.92446586
Iter-190, train loss: 4.17512272, valid loss: 1842.55530443
Iter-191, train loss: 4.17173660, valid loss: 1842.05033654
Iter-192, train loss: 4.16813610, valid loss: 1841.39785233
Iter-193, train loss: 4.16432196, valid loss: 1840.58634711
Iter-194, train loss: 4.16029577, valid loss: 1839.60634200
Iter-195, train loss: 4.15605995, valid loss: 1838.45137321
Iter-196, train loss: 4.15161777, valid loss: 1837.11796658
Iter-197, train loss: 4.14697335, valid loss: 1835.60460786
Iter-198, train loss: 4.14213169, valid loss: 1833.91003431
Iter-199, train loss: 4.13709865, valid loss: 1832.03132545
Iter-200, train loss: 4.13188098, valid loss: 1829.96224172






    
Out[17]:





<__main__.GRU at 0x7f161bd86c50>

In [18]:

    

import matplotlib.pyplot as plt

plt.plot(net.losses['train'], label='Train loss')
plt.plot(net.losses['smooth train'], label='Train smooth loss')
plt.legend()
plt.show()


    

In [19]:

    

import matplotlib.pyplot as plt

plt.plot(net.losses['valid'], label='Validation loss')
plt.legend()
plt.show()


    

In [23]:

    

import matplotlib.pyplot as plt

y_pred = net.test(X_seed=X_valid[0], h=net.initial_state(), size=X_valid.shape[0]) # ys_tx1xn
y_pred.shape, Y_valid.shape

plt.plot(y_pred[:350], label='y_pred')
plt.plot(Y_valid[:350], label='Y_valid')
# plt.plot(X_valid[:100], label='X_valid')
plt.legend()
plt.show()


    

In [ ]:

    




    

In [ ]: