49.pdf

    1. import  numpy as np
    2. import  torch
    3. import  torch.nn as nn
    4. import  torch.optim as optim
    5. from    matplotlib import pyplot as plt
    8. num_time_steps = 50
    9. input_size = 1
    10. hidden_size = 16
    11. output_size = 1
    12. lr=0.01
    16. class Net(nn.Module):
    18.     def __init__(self, ):
    19.         super(Net, self).__init__()
    21.         self.rnn = nn.RNN(
    22.             input_size=input_size,
    23.             hidden_size=hidden_size,
    24.             num_layers=1,
    25.             batch_first=True,
    26.         )
    27.         for p in self.rnn.parameters():
    28.           nn.init.normal_(p, mean=0.0, std=0.001)
    30.         self.linear = nn.Linear(hidden_size, output_size)
    32.     def forward(self, x, hidden_prev):
    34.        out, hidden_prev = self.rnn(x, hidden_prev)
    35.        # [b, seq, h]
    36.        out = out.view(-1, hidden_size)
    37.        out = self.linear(out)
    38.        out = out.unsqueeze(dim=0)
    39.        return out, hidden_prev
    44. model = Net()
    45. criterion = nn.MSELoss()
    46. optimizer = optim.Adam(model.parameters(), lr)
    48. hidden_prev = torch.zeros(1, 1, hidden_size)
    50. for iter in range(6000):
    51.     start = np.random.randint(3, size=1)[0]
    52.     time_steps = np.linspace(start, start + 10, num_time_steps)
    53.     data = np.sin(time_steps)
    54.     data = data.reshape(num_time_steps, 1)
    55.     x = torch.tensor(data[:-1]).float().view(1, num_time_steps - 1, 1)
    56.     y = torch.tensor(data[1:]).float().view(1, num_time_steps - 1, 1)
    58.     output, hidden_prev = model(x, hidden_prev)
    59.     hidden_prev = hidden_prev.detach()
    61.     loss = criterion(output, y)
    62.     model.zero_grad()
    63.     loss.backward()
    64.     # for p in model.parameters():
    65.     #     print(p.grad.norm())
    66.     # torch.nn.utils.clip_grad_norm_(p, 10)
    67.     optimizer.step()
    69.     if iter % 100 == 0:
    70.         print("Iteration: {} loss {}".format(iter, loss.item()))
    72. start = np.random.randint(3, size=1)[0]
    73. time_steps = np.linspace(start, start + 10, num_time_steps)
    74. data = np.sin(time_steps)
    75. data = data.reshape(num_time_steps, 1)
    76. x = torch.tensor(data[:-1]).float().view(1, num_time_steps - 1, 1)
    77. y = torch.tensor(data[1:]).float().view(1, num_time_steps - 1, 1)
    79. predictions = []
    80. input = x[:, 0, :]
    81. for _ in range(x.shape[1]):
    82.   input = input.view(1, 1, 1)
    83.   (pred, hidden_prev) = model(input, hidden_prev)
    84.   input = pred
    85.   predictions.append(pred.detach().numpy().ravel()[0])
    87. x = x.data.numpy().ravel()
    88. y = y.data.numpy()
    89. plt.scatter(time_steps[:-1], x.ravel(), s=90)
    90. plt.plot(time_steps[:-1], x.ravel())
    92. plt.scatter(time_steps[1:], predictions)
    93. plt.show()