Hi there,
I’m trying to built a regression model for predicting a one dimensional timeseries from multiple timeseries signals.
I’m using a GRU. However I got a couple problems/questions:


If I train my model in batches. Do I also have to predict in batches? (If not, how can I predict without using a batch)


How can I include batch normalization for the GRU?


Also I’m quite new to pytorch. If anyone has some advice on how to improve my code. I’ll be thankful for any comment.


That’s my entire code:
import torch
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
import torch.optim as optim

class GRU_BF(nn.Module):
    def __init__(self,input_size,hidden_size,num_layers,time_steps,bidirectional=False):
        super().__init__()
        
        self.input_size=input_size
        self.hidden_size=hidden_size
        self.num_layers=num_layers
        self.time_steps=time_steps
        
        self.bidirectional=bidirectional
        
        self.GRU_lyrs=nn.GRU(input_size = input_size,hidden_size = hidden_size,num_layers = num_layers,batch_first=True,bidirectional=bidirectional)
        self.outp=nn.Linear(time_steps,time_steps)
        self.outp2=nn.Linear(time_steps,time_steps)
        
        return
    
    def forward(self,x,hstate):
        x,hstate=self.GRU_lyrs(x,hstate)
        hstate = Variable(hstate.data)
        x=F.relu(self.outp(x[:, :, -1]))
        x=self.outp2(x)
        return x, hstate
    
    
class SamplerBF():
    def __init__(self):
        self.count=0
        return
    
    def sample(self,batchsize):
        X1=[]
        X2=[]
        Y=[]
        num_ts=400
        for i in range(batchsize):
            x=np.linspace(self.count*np.pi,(self.count+4)*np.pi,num_ts)
            x1=np.sin(x)
            X1.append(x1)
            x2=np.cos(x)+2
            X2.append(x2)
            Y.append((x1/x2))
            self.count+=1
        return np.swapaxes(np.array([X1,X2]).T,0,1),np.array(Y)
    
input_dim=2
hidden_size=200
num_layers=2
time_steps=400

lossvals=[]

S=SamplerBF()

mynn=GRU_BF(input_size=input_dim,hidden_size=hidden_size,num_layers=num_layers,time_steps=time_steps)
h_state=None

optimizer=optim.Adam(mynn.parameters(),lr=0.01,weight_decay=0)
scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.954)

#train
for i in range(20):
    mynn.train()
    x,y=S.sample(30)
    X=torch.Tensor(x)
    Y=torch.Tensor(y)

    Y_pred, h_state = mynn(X,h_state)
    
    scheduler.step()
    
    error=nn.MSELoss()
    loss=error(Y_pred,Y)
    mynn.zero_grad()

    loss.backward()

    optimizer.step()

    lossvals.append(loss.item())
    print("It: ",i,lossvals[-1])
    
plt.semilogy(lossvals)



#predict/eval
with torch.no_grad():
    mynn.eval()

    # I would love to predict without using the same amout of batches, that I used for training
    x,y=S.sample(30)

    X=torch.Tensor(x)
    Y=torch.Tensor(y)

    Y_pred, h_state = mynn(X,h_state)

    for i in range(2):
        fig,ax = plt.subplots(1,1,figsize=(12,6))
        ax.plot(y[i],"ko",Y_pred[i].data.numpy(),"r*")
        plt.show()


Thanks for any hint in advance!!
Have a good one!