Python Pyrotch LSTM不会过度拟合单个样本

我试图过拟合单个时间序列。也就是说，我尝试在单个

（X，Y）

对上一遍又一遍地执行训练。我这样做是为了对超参数的功能有一个印象。但它并不收敛。这是损失图，显示了大约800次迭代后每次迭代的MSE：

我希望错误完全消失，但当我写这篇文章时，它被卡在了平台上，它仍然在那里。 时间序列的长度为29600，RNN将一个值映射到另一个值。它由一个带有

1

输入、

200

隐藏单元的LSTM单元和一个完全连接的映射到单个值的层组成

我的感觉告诉我，模型可能不够复杂，不适合样本。但在我尝试增加RNN的复杂性之前，我必须确保我的培训实施是正确的。也许我没有正确地使用autograd。因为这是我第一次尝试训练神经网络，我不知道需要多长时间

import torch
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable    
import numpy as np

# the class containing the LSTM
class Sequence(nn.Module):
    def __init__(self):
        self.hidden_state_len = 200
        super(Sequence, self).__init__()
        self.lstm1 = nn.LSTMCell(1, self.hidden_state_len)        
        self.linear = nn.Linear(self.hidden_state_len, 1)
        h_t = torch


    def forward(self, input):
        outputs = []
        h_t = torch.zeros(input.size(0), self.hidden_state_len, dtype=torch.double).cuda()
        c_t = torch.zeros(input.size(0), self.hidden_state_len, dtype=torch.double).cuda()

        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)
            outputs += [output]

        return torch.cat(outputs, dim=1)


x1 = torch.load("/floyd/input/wav/x1.pt").double().cuda()[0][7400:37000].reshape(1,-1)
y1 = torch.load("/floyd/input/wav/y1.pt").double().cuda()[0][7400:37000].reshape(1,-1)

seq = Sequence()
seq.double()

criterion = nn.MSELoss()
seq = seq.cuda()
device = torch.device("cuda:0")
seq = seq.to(device)

optimizer = optim.Adam(seq.parameters())
starttime = datetime.datetime.now()
i = -1

# training for 4 hours on cloud GPU
while((datetime.datetime.now() - starttime).total_seconds() < 60*60*4) :
    i+=1
    optimizer.zero_grad()
    input = Variable(x1)
    target = Variable(y1)
    out = seq(input)    
    loss = criterion(out, target)
    loss.backward()    
    optimizer.step()

导入火炬
导入torch.nn作为nn
将torch.optim导入为optim
从torch.autograd导入变量
将numpy作为np导入
#包含LSTM的类
类序列（nn.模块）：
定义初始化（自）：
self.hidden\u state\u len=200
超级（序列，自我）。\uuuu初始化\uuuuu（）
self.lstm1=nn.LSTMCell（1，self.hidden\u state\u len）
self.linear=nn.linear（self.hidden\u state\u len，1）
h_t=火炬
def前进（自我，输入）：
输出=[]
h_t=torch.zero（input.size（0），self.hidden_state_len，dtype=torch.double）.cuda（）
c_t=torch.zero（input.size（0），self.hidden_state_len，dtype=torch.double）.cuda（）
对于i，在枚举中输入（input.chunk（input.size（1），dim=1））：
h_t，c_t=self.lstm1（输入（h_t，c_t））
输出=自线性（h_t）
输出+=[输出]
返回火炬。cat（输出，尺寸=1）
x1=torch.load（“/floyd/input/wav/x1.pt”）.double（）.cuda（）[0][7400:37000]。重塑（1，-1）
y1=torch.load（“/floyd/input/wav/y1.pt”）.double（）.cuda（）[0][7400:37000]。重塑（1，-1）
seq=序列（）
seq.double（）
标准=nn.MSELoss（）
seq=seq.cuda（）
设备=火炬。设备（“cuda:0”）
序号=序号至（设备）
optimizer=optim.Adam（seq.parameters（））
starttime=datetime.datetime.now（）
i=-1
#在云GPU上培训4小时
而（（datetime.datetime.now（）-starttime）.total_seconds（）<60*60*4）：
i+=1
optimizer.zero_grad（）
输入=变量（x1）
目标=变量（y1）
输出=顺序（输入）
损失=标准（输出、目标）
loss.backward（）
optimizer.step（）

仅用于测试，您是否尝试过使用

LSTM

而不是

LSTMCell

。我没有看到任何特殊的操作需要在你的

前进

方法中循环。而且，你的训练周期在我看来是正确的。如果你坚持完全过度拟合，你可能想使用衰减的学习率，但即使如此，也不能保证找到一个全局最小值。这就是非凸优化问题的关键所在。为了测试，您是否尝试过使用

LSTM

而不是

LSTMCell

。我没有看到任何特殊的操作需要在你的

前进

方法中循环。而且，你的训练周期在我看来是正确的。如果你坚持完全过度拟合，你可能想使用衰减的学习率，但即使如此，也不能保证找到一个全局最小值。这就是非凸优化问题的关键所在。