import torch.nn
cell=torch.nn.RNNCell(input_size=3,hidden_size=2)
for name,param in cell.named_parameters():
    print('{}={}'.format(name,param))

#构造LSTM类实例并用其搭建单层RNN
import torch.nn
import torch
seq_len,batch_size=6,2
input_size,hidden_size=3,5

cell=torch.nn.LSTMCell(input_size=input_size,hidden_size=hidden_size)
inputs=torch.randn(seq_len,batch_size,input_size)
h=torch.randn(batch_size,hidden_size)
c=torch.randn(batch_size,hidden_size)
hs=[]
for t in range(seq_len):
    h,c=cell(inputs[t],(h,c))
    hs.append(h)
outputs=torch.stack(hs)
print(hs)
outputs

import torch
import torch.nn
num_layer=2 #神经网络的层数
seq_len,batch_size=6,2
input_size,hidden_size=3,5
rnn=torch.nn.GRU(input_size,hidden_size,num_layer)
inputs=torch.randn(seq_len,batch_size,input_size)
h0=torch.randn(num_layer,batch_size,hidden_size)
outputs,hn=rnn(inputs,h0)
outputs

from pandas_datareader import wb
countries=['BR','CA','CN','FR','DE','IN','IL','JP','SA','GB','US']
dat=wb.download(indicator='NY.GDP.PCAP.KD',country=countries,start=1970,end=2017)
df=dat.unstack().T
df.index=df.index.droplevel(0)
df

import torch.nn
class Net(torch.nn.Module):
    def __init__(self,input_size,hidden_size):
        super(Net,self).__init__()
        self.rnn=torch.nn.LSTM(input_size,hidden_size)
        self.fc=torch.nn.Linear(hidden_size,1)
    
    def forward(self,x):
        x=x[:,:,None]
        x,_=self.rnn(x)
        x=self.fc(x)
        x=x[:,:,0]
        return x
net=Net(input_size=1,hidden_size=5)
print(net)

import torch
import torch.optim
from IPython.display import display
import pandas as pd


#归一化
df_scaled=df / df.loc['2000']#原书上此处有错误
#确定训练集合测试集
years=df.index
print(years)
train_seq_len=sum((years>='1971')&(years<='2000'))
test_seq_len=sum(years>'2000')
print('训练集长度={},测试集长度={}'.format(train_seq_len,test_seq_len))

#确定训练使用数据的特征和标签
inputs=torch.tensor(df_scaled.iloc[:-1].values,dtype=torch.float32)
labels=torch.tensor(df_scaled.iloc[1:].values,dtype=torch.float32)

#训练网络
criterion=torch.nn.MSELoss()
optimizer=torch.optim.Adam(net.parameters())
test_loss_count=[1]
count=1
for step in range(10001):
    if step:
        optimizer.zero_grad()
        train_loss.backward()
        optimizer.step()
    preds=net(inputs)
    train_preds=preds[:train_seq_len]
    train_labels=labels[:train_seq_len]
    train_loss=criterion(train_preds,train_labels)
    
    test_preds=preds[-test_seq_len:]
    test_labels=labels[-test_seq_len:]
    test_loss=criterion(test_preds,test_labels)
    count=count+1
    
    if step%500==0:
        print('第{}次迭代：loss(训练集)={},loss(测试集)={}'.format(step,train_loss,test_loss))
    if test_loss<test_loss_count[-1]:
        test_loss_count.append(test_loss)
        count=0
        pred_count=preds
    if count>500:
        break
    
 
    
    

from IPython.display import display
import pandas as pd
preds=net(inputs)
df_pred_scaled=pd.DataFrame(pred_count.detach().numpy(),index=years[1:],columns=df.columns)
df_pred=df_pred_scaled*df.loc['2000']
display(df_pred.loc['2001':])

import matplotlib.pyplot as plt
%matplotlib inline
y=df_pred.loc[:,'France']
x=df.loc[:,'France']
plt.plot(x,label='origininal data')
plt.plot(y,label='predicted results')
plt.legend()

len(labels[-test_seq_len:])

import jovian
jovian.commit("rnn_temp.ipynb")