In [1]:

    

# 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[1]:







  

    

      

      
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 [2]:

    

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


    

In [3]:

    

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 [4]:

    

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[4]:





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

In [5]:

    

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 [6]:

    

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 [7]:

    

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

class GRU:
    def __init__(self, D, H, L, p_dropout):
        self.D = D
        self.H = H
        self.L = L
        self.p_dropout = p_dropout
        self.losses = {'train':[], 'smooth train':[], 'valid': []}
        
        # Model params
        Z = H + D
        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.),
            bz=np.zeros((1, H)),
            br=np.zeros((1, H)),
            bh=np.zeros((1, H)),
            by=np.zeros((1, D))
        )
        self.model = []
        for _ in range(self.L):
            self.model.append(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, do_caches = [], [], []

        for X in X_train:
            X = X.reshape(1, -1) # X_1xn
            for layer in range(self.L):
                y, h, fc_cache = self.forward(X, h, self.model[layer])
                y, do_cache = l.dropout_forward(y, self.p_dropout)
                X = y.copy()
            fc_caches.append(fc_cache)
            do_caches.append(do_cache)
            ys.append(y)
        
        ys = np.array(ys, dtype=float).reshape(len(ys), -1) # ys_txn instead of ys_tx1xn
        caches = (fc_caches, do_caches)
        
        return ys, caches
                                
    def loss_function(self, y_pred, y_train): # , alpha alpha: learning rate
        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, do_caches = caches
        
        dh = np.zeros((1, self.H)) 
        grad = {key: np.zeros_like(val) for key, val in self.model[0].items()}
        grads = [] #{key: np.zeros_like(val) for key, val in self.model.items()}
        for _ in range(self.L):
            grads.append(grad)

        for t in reversed(range(len(dys))):
            dy = dys[t].reshape(1, -1) # dy_1xn
            for layer in reversed(range(self.L)):
                dy = l.dropout_backward(dy, do_caches[t])
                dX, dh, grad = self.backward(dy, dh, fc_caches[t])
                dy = dX.copy() # for the previous layer
                for key in grad.keys():
                    grads[layer][key] += grad[key]
                
        return dX, grads
    
    def test(self, X_seed, h, size):
        ys = []
        X = X_seed.reshape(1, -1)
        for _ in range(size):
            for layer in range(self.L):
                y, h, _ = self.forward(X, h, self.model[layer])
                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 [8]:

    

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

    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()}
    for _ in range(nn.L):
        M.append({key: np.zeros_like(val) for key, val in nn.model[0].items()})
        R.append({key: np.zeros_like(val) for key, val in nn.model[0].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 layer in range(nn.L):
                for key in grads[0].keys(): # key, value, items
                    M[layer][key] = l.exp_running_avg(M[layer][key], grads[layer][key], beta1)
                    R[layer][key] = l.exp_running_avg(R[layer][key], grads[layer][key]**2, beta2)
                    m_k_hat = M[layer][key] / (1. - (beta1** iter))
                    r_k_hat = R[layer][key] / (1. - (beta2** iter))
                    nn.model[layer][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 [ ]:

    

# Hyper-parameters
time_step = 64 # minibatch size: 32, 64, 128, or 256 Cache
n_iter = 1000 # 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
num_hidden_layers = 4 # number of hidden layers
keep_prob = 0.95 # p_dropout == keep_prob

# 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, p_dropout=keep_prob, L=num_hidden_layers) # , lam=lam, L=num_layers, p_dropout=p_dropout

# 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: 30.42036800, valid loss: 7334.95215641
Iter-2, train loss: 30.31270174, valid loss: 6920.96622310
Iter-3, train loss: 31.21024091, valid loss: 8700.35618876
Iter-4, train loss: 29.94718123, valid loss: 8227.67099612
Iter-5, train loss: 28.60228483, valid loss: 10443.45127408
Iter-6, train loss: 30.79936372, valid loss: 8737.72094699
Iter-7, train loss: 29.68131664, valid loss: 8918.09649514
Iter-8, train loss: 29.96395740, valid loss: 7812.51860532
Iter-9, train loss: 30.51919143, valid loss: 7178.36512069
Iter-10, train loss: 30.79512756, valid loss: 5687.06549499
Iter-11, train loss: 29.20008239, valid loss: 7967.67315933
Iter-12, train loss: 30.38063277, valid loss: 5310.77176023
Iter-13, train loss: 30.78931562, valid loss: 4634.97238353
Iter-14, train loss: 30.75465755, valid loss: 4068.28313607
Iter-15, train loss: 32.43431433, valid loss: 4930.56704243
Iter-16, train loss: 30.87540361, valid loss: 3706.05653320
Iter-17, train loss: 30.86663596, valid loss: 4074.26215464
Iter-18, train loss: 30.06850553, valid loss: 1768.78089362
Iter-19, train loss: 30.31058390, valid loss: 3464.10529540
Iter-20, train loss: 32.19880197, valid loss: 4030.01213816
Iter-21, train loss: 30.37488703, valid loss: 3828.56594656
Iter-22, train loss: 29.25706882, valid loss: 4235.68045386
Iter-23, train loss: 29.24618819, valid loss: 3881.80736041
Iter-24, train loss: 30.36780368, valid loss: 2716.00535641
Iter-25, train loss: 30.14002042, valid loss: 1767.47452890
Iter-26, train loss: 29.06509866, valid loss: 1623.83311755
Iter-27, train loss: 30.45503887, valid loss: 2007.41210771
Iter-28, train loss: 30.82839916, valid loss: 2200.99126875
Iter-29, train loss: 30.70512439, valid loss: 1698.31151247
Iter-30, train loss: 29.16717135, valid loss: 891.75633018
Iter-31, train loss: 29.67052149, valid loss: 2390.09789454
Iter-32, train loss: 30.78239213, valid loss: 1378.32918427
Iter-33, train loss: 31.12722712, valid loss: 4257.58358036
Iter-34, train loss: 30.69835968, valid loss: 1704.52805084
Iter-35, train loss: 31.73536779, valid loss: 3928.00549559
Iter-36, train loss: 30.06468250, valid loss: 5645.16598188
Iter-37, train loss: 27.56784828, valid loss: 8506.15733951
Iter-38, train loss: 27.88479875, valid loss: 7603.91388902
Iter-39, train loss: 31.13049001, valid loss: 1586.57812235
Iter-40, train loss: 32.10448760, valid loss: 4876.44603970
Iter-41, train loss: 30.19801006, valid loss: 3357.72553607
Iter-42, train loss: 30.41735066, valid loss: 7561.36744739
Iter-43, train loss: 29.47666088, valid loss: 1400.73298454
Iter-44, train loss: 30.78931562, valid loss: 3478.87190529
Iter-45, train loss: 31.92161387, valid loss: 5569.49170912
Iter-46, train loss: 31.12785031, valid loss: 6693.41866768
Iter-47, train loss: 29.57209729, valid loss: 5863.33141642
Iter-48, train loss: 30.03205513, valid loss: 5237.91459937
Iter-49, train loss: 29.57975699, valid loss: 4594.76897214
Iter-50, train loss: 27.12398047, valid loss: 3550.14074027
Iter-51, train loss: 31.67482236, valid loss: 2130.60033914
Iter-52, train loss: 30.15038002, valid loss: 2924.88706687
Iter-53, train loss: 31.32467491, valid loss: 1823.25422102
Iter-54, train loss: 30.84614245, valid loss: 1952.04083261
Iter-55, train loss: 32.60933626, valid loss: 1399.57880881
Iter-56, train loss: 30.56957649, valid loss: 1284.81911075
Iter-57, train loss: 29.63311902, valid loss: 889.30637752
Iter-58, train loss: 29.90456889, valid loss: 2957.93270057
Iter-59, train loss: 31.51516034, valid loss: 1340.49227077
Iter-60, train loss: 30.64856176, valid loss: 861.58082282
Iter-61, train loss: 28.89824380, valid loss: 915.49807118
Iter-62, train loss: 30.70223919, valid loss: 743.19724795
Iter-63, train loss: 29.57140993, valid loss: 826.09334946
Iter-64, train loss: 30.44029667, valid loss: 1024.09136850
Iter-65, train loss: 27.96314322, valid loss: 1240.14686520
Iter-66, train loss: 33.82558910, valid loss: 2623.58352915
Iter-67, train loss: 28.85444080, valid loss: 897.16222503
Iter-68, train loss: 30.36459548, valid loss: 1431.40011369
Iter-69, train loss: 30.24574798, valid loss: 678.15262221
Iter-70, train loss: 27.41192896, valid loss: 715.38275994
Iter-71, train loss: 30.66591789, valid loss: 745.05883375
Iter-72, train loss: 29.35565490, valid loss: 717.33641377
Iter-73, train loss: 30.62095722, valid loss: 1069.63389491
Iter-74, train loss: 30.78183967, valid loss: 1070.40970792
Iter-75, train loss: 30.78512626, valid loss: 731.32094615
Iter-76, train loss: 33.92140787, valid loss: 736.54125644
Iter-77, train loss: 30.66114623, valid loss: 693.16021563
Iter-78, train loss: 29.61292448, valid loss: 650.44502558
Iter-79, train loss: 31.50860755, valid loss: 688.97743405
Iter-80, train loss: 31.86448741, valid loss: 856.67706111
Iter-81, train loss: 30.21249525, valid loss: 813.37956404
Iter-82, train loss: 31.16610939, valid loss: 874.80525408
Iter-83, train loss: 32.82571403, valid loss: 1022.98208771
Iter-84, train loss: 31.16475936, valid loss: 2025.15279714
Iter-85, train loss: 41.55517073, valid loss: 5525.38236314
Iter-86, train loss: 33.22886333, valid loss: 5602.35802896
Iter-87, train loss: 40.20441426, valid loss: 5534.00667914
Iter-88, train loss: 38.76773291, valid loss: 5364.31238631
Iter-89, train loss: 36.71156152, valid loss: 5333.64636148
Iter-90, train loss: 32.36130285, valid loss: 5405.42354206
Iter-91, train loss: 36.85971328, valid loss: 4939.86355439
Iter-92, train loss: 41.37090034, valid loss: 3805.48042866
Iter-93, train loss: 37.59836044, valid loss: 2824.93434094
Iter-94, train loss: 35.06117179, valid loss: 2902.60971884
Iter-95, train loss: 32.03247636, valid loss: 2902.53418755
Iter-96, train loss: 38.85430795, valid loss: 2902.48746116
Iter-97, train loss: 35.49272518, valid loss: 2901.35075318
Iter-98, train loss: 31.94777323, valid loss: 2898.82232185
Iter-99, train loss: 31.28824108, valid loss: 2873.23281849
Iter-100, train loss: 32.08176214, valid loss: 2854.48753443
Iter-101, train loss: 35.79116867, valid loss: 2853.89252029
Iter-102, train loss: 40.76945035, valid loss: 2682.67244756
Iter-103, train loss: 31.31386778, valid loss: 2382.11986734
Iter-104, train loss: 27.78360948, valid loss: 2022.37146401
Iter-105, train loss: 30.00563864, valid loss: 1306.68285243
Iter-106, train loss: 31.07295132, valid loss: 787.44084447
Iter-107, train loss: 31.90853169, valid loss: 771.04937079
Iter-108, train loss: 31.05639727, valid loss: 813.73766043
Iter-109, train loss: 29.88218108, valid loss: 805.75143149
Iter-110, train loss: 29.34578369, valid loss: 805.72672197
Iter-111, train loss: 29.79015895, valid loss: 805.58538869
Iter-112, train loss: 27.29848731, valid loss: 805.19176840
Iter-113, train loss: 29.68630727, valid loss: 805.84079790
Iter-114, train loss: 30.10386280, valid loss: 808.37997670
Iter-115, train loss: 29.75366892, valid loss: 818.38885163
Iter-116, train loss: 30.03211379, valid loss: 786.62753619
Iter-117, train loss: 29.95940289, valid loss: 806.64138817
Iter-118, train loss: 29.69853836, valid loss: 864.06530312
Iter-119, train loss: 31.33972346, valid loss: 812.03291629
Iter-120, train loss: 30.09851272, valid loss: 1948.56793920
Iter-121, train loss: 30.80573518, valid loss: 4515.05078479
Iter-122, train loss: 30.19475917, valid loss: 5110.82467403
Iter-123, train loss: 30.57548279, valid loss: 6849.53940442
Iter-124, train loss: 29.73466160, valid loss: 5071.14952301
Iter-125, train loss: 30.61594199, valid loss: 6857.92044118
Iter-126, train loss: 30.37442218, valid loss: 8201.26963312
Iter-127, train loss: 29.64271974, valid loss: 5988.39769860
Iter-128, train loss: 31.07466918, valid loss: 3004.00970760
Iter-129, train loss: 30.48736185, valid loss: 3294.38799868
Iter-130, train loss: 30.10487785, valid loss: 3790.17047544
Iter-131, train loss: 30.57169367, valid loss: 3946.72840620
Iter-132, train loss: 28.81175340, valid loss: 7095.60716131
Iter-133, train loss: 30.47419738, valid loss: 6033.42484491
Iter-134, train loss: 30.39312344, valid loss: 1378.56647552
Iter-135, train loss: 29.60193251, valid loss: 894.02636250
Iter-136, train loss: 30.82877935, valid loss: 1898.16673526
Iter-137, train loss: 30.43219047, valid loss: 1511.03636013
Iter-138, train loss: 31.63880336, valid loss: 1268.23232815
Iter-139, train loss: 31.27198282, valid loss: 5285.48938395
Iter-140, train loss: 30.14304293, valid loss: 5220.39444007
Iter-141, train loss: 30.94204475, valid loss: 6849.79992681
Iter-142, train loss: 30.57190674, valid loss: 6234.88132193
Iter-143, train loss: 30.51336542, valid loss: 8361.96857860
Iter-144, train loss: 28.99510514, valid loss: 7443.39866418
Iter-145, train loss: 30.45850341, valid loss: 641.07974658
Iter-146, train loss: 30.47088464, valid loss: 902.07998447
Iter-147, train loss: 29.31054330, valid loss: 1194.81548551
Iter-148, train loss: 31.02775280, valid loss: 762.25240313
Iter-149, train loss: 30.22733409, valid loss: 749.38284889
Iter-150, train loss: 29.95072766, valid loss: 702.02758966
Iter-151, train loss: 30.71241853, valid loss: 696.81172564

In [ ]:

    

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 [ ]:

    

import matplotlib.pyplot as plt

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


    

In [ ]:

    

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[:100, 1], label='y_pred')
plt.plot(Y_valid[:100, 1], label='Y_valid')
# plt.plot(X_valid[:100], label='X_valid')
plt.legend()
plt.show()


    

In [ ]:

    




    

In [ ]: