I see the exact issue now. Your subclassing of autograd.Variable is wrong. Replace it instead with this if you want:
def Variable(data, *args, **kwargs):
    return autograd.Variable(data.cuda(), *args, **kwargs)

Here’s a working example:
import torch
import torch.nn as nn
from torch import autograd
import torch.optim as optim
import numpy as np
import matplotlib
matplotlib.use('Agg')

def Variable(data, *args, **kwargs):
    return autograd.Variable(data.cuda(), *args, **kwargs)

class Sequence(nn.Module):
    def __init__(self):
        super(Sequence, self).__init__()
        self.lstm1 = nn.LSTMCell(1, 51).cuda()
        self.lstm2 = nn.LSTMCell(51, 1).cuda()

    def forward(self, input, future = 0):
        input = input.cuda()
        outputs = []
        h_t = Variable(torch.zeros(input.size(0), 51), requires_grad=False)
        c_t = Variable(torch.zeros(input.size(0), 51), requires_grad=False)
        h_t2 = Variable(torch.zeros(input.size(0), 1), requires_grad=False)
        c_t2 = Variable(torch.zeros(input.size(0), 1), requires_grad=False)
        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))
            h_t2, c_t2 = self.lstm2(c_t, (h_t2, c_t2))
            outputs += [c_t2]
        for i in range(future):# if we should predict the future
            h_t, c_t = self.lstm1(c_t2, (h_t, c_t))
            h_t2, c_t2 = self.lstm2(c_t, (h_t2, c_t2))
            outputs += [c_t2]
        outputs = torch.stack(outputs, 1).squeeze(2)
        return outputs



if __name__ == '__main__':
    # set ramdom seed to 0
    np.random.seed(0)
    torch.manual_seed(0)
    # load data and make training set
    data = torch.load('traindata.pt')
    input = Variable(torch.from_numpy(data[3:, :-1]), requires_grad=False)
    target = Variable(torch.from_numpy(data[3:, 1:]), requires_grad=False).cuda()
    # build the model
    seq = Sequence()
    #seq.double()
    seq.cuda()
    criterion = nn.MSELoss()
    # use LBFGS as optimizer since we can load the whole data to train
    optimizer = optim.LBFGS(seq.parameters())
    #begin to train
    for i in range(10):
        print('STEP: ', i)
        def closure():
            optimizer.zero_grad()
            out = seq(input).cuda()
            loss = criterion(out, target)
            print('loss:', loss.data.cpu().numpy()[0])
            loss.backward()
            return loss
        optimizer.step(closure)
        # begin to predict
        future = 1000
        pred = seq(input[:3], future = future)
        y = pred.data.numpy()