I am trying to create an LSTM model that to predict some time series data.
My data is configured as follows:
Input instances:
[0.99, 0.98, 1.01, 1.03, 1.001, 0.98, 1.001]
Target Value:
[0.995]
So each instance is a vector of seven values used to predict the target.
I am trying to keep my model simple to start so here are the components"
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.lstm1 = nn.LSTM(input_size=7, hidden_size=51, num_layers=1)
        self.linear = nn.Linear(in_features=51, out_features=1)

    def forward(self, input, future = 0):
        outputs = []
        h_t = torch.rand(input.size(1)*1, 1, 51, dtype=torch.double)
        c_t = torch.rand(input.size(1)*1, 1, 51, dtype=torch.double)

        for i, input_t in enumerate(input.chunk(input.size(1), dim=1)):
            h_t, c_t = self.lstm1(input_t, (h_t, c_t))
            output = self.linear(h_t)
            output = output.add(1e-8)
            outputs += [output]

        for i in range(future):
            h_t, c_t = self.lstm1(output, (h_t, c_t))
            output = self.linear(h_t)
            outputs += [output]

        outputs = torch.stack(outputs, 1).squeeze(2)
        return outputs

This is called from the following:
    ...
    traindataloader = DataLoader(train_data,
                                 batch_size=500,
                                 shuffle=True,
                                 num_workers=4)

    model = MyModel().double()
    criterion = nn.MSELoss(reduction='sum') # I have also tried 'none' and 'elementwise_mean'
    optimizer = optim.Adam(model.parameters(), lr=1e-06, weight_decay=0.1)

    for i in range(10):
        optimizer.zero_grad()
        print(f"{Fore.BLUE}STEP: ", i, f"{Style.RESET_ALL}")

        inputs = None
        targets = None
        for idx, data in enumerate(traindataloader):
            def closure():
                y_pred = model(inputs)
                loss = criterion(y_pred, targets)
                print('Loss:', loss.item())
                loss.backward()
                return loss
            inputs, targets = data
            optimizer.step(closure)

Using this code, I can get through one mini batch of inputs before the loss goes to inf and then to nan.
My questions are:

Is my data structured correctly for an LSTM?
Is my model correct / appropriate?
Is the DataLoader used correctly?  (It seems to be)

From my research, it appears I have an exploding gradient, and I have tried several ways to resolve this, but I cannot find the right combination.
I am running this on PyTorch 0.41/Python 3.6
Any help would be greatly appreciated.