RNN 无法学习积分函数

Question

为了研究深度学习、RNN、LSTM等，我尝试让RNN拟合积分函数。我已将 0 到 1 的随机信号作为 RNN 的输入，并从偏置 -0.5 的输入信号进行积分，将积分限制在 0:1 之间并将其作为 RNN 目标进行学习。 Blue - random input, orange - integrated input

所以我有一个只有一个输入（随机）和一个输出（输入的有限积分）的时间序列，我希望 RNN 通过输入来预测输出。 我使用 Pytorch 并尝试使用 vanilla RNN、GRU 单元、不同大小的隐藏层、堆叠多个 RNN、将密集连接层放置到 RNN 输出、随时间的反向传播深度不同（从 2 到 50 个梯度回滚）。而且我根本得不到好结果！它以某种方式工作，但我找不到精确拟合积分函数的方法。这是我最好的结果： green - RNN output。 绿线（模型输出）在许多情况下不适合橙线 - 这就是问题所在。

Here is my source code in jupyter。 我的问题：有可能 - 通过 RNN 学习饱和积分函数吗？我的问题在哪里？我可以尝试更多以达到良好的质量吗？ 理想情况下，我希望 RNN 输出在所有时间序列中都等于所需的输出（积分函数）。

PS： 我的原始格式代码：

import numpy as np
from scipy.stats import truncnorm
import random
import math
import copy
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import matplotlib.cm as cm

def generate_data(num_of_data):
    input_data=[]
    output_data=[]
    current_input_value=0
    current_output_value=0
    for i in range(num_of_data):
        if (random.random()<0.1):
            current_input_value=random.random()
#            current_output_value=0
        current_input_value=current_input_value+(random.random()-0.5)*0
        current_output_value=current_output_value+0.0*(current_input_value-current_output_value)+(current_input_value-0.5)*0.1
        if (current_output_value<0):
            current_output_value=0
        if (current_output_value>1):
            current_output_value=1

        input_data.append(current_input_value)
        output_data.append(current_output_value)
    return input_data,output_data

%matplotlib inline
matplotlib.rcParams['figure.figsize'] = (20, 6)

input_data,output_data=generate_data(500)
plt.plot(input_data)
plt.plot(output_data)
plt.show()


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


class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()
        self.number_of_layers=1
        self.hidden_size = hidden_size
        self.gru = nn.GRU(input_size, hidden_size,self.number_of_layers)
        self.Dense1 = nn.Linear(hidden_size, hidden_size)
        self.Dense1A = nn.ReLU()
        self.Dense2 = nn.Linear(hidden_size, output_size)


    def forward(self, input, hidden):
        gru_output, hidden = self.gru(input, hidden)
        Dense1Out=self.Dense1(gru_output)
        Dense1OutAct=self.Dense1A(Dense1Out)
        output=self.Dense2(Dense1OutAct)
        return output, hidden

    def initHidden(self):
        return Variable(torch.zeros(self.number_of_layers,1,self.hidden_size))



import time
import math
import operator

def timeSince(since):
    now = time.time()
    s = now - since
    m = math.floor(s / 60)
    s -= m * 60
    return '%dm %ds' % (m, s)
rnn = RNN(1, 50, 1)

n_iters = 250000
print_every = 2000
plot_every = 2000
all_losses = []
total_loss_print = 0
total_loss_plot = 0

criterion=nn.L1Loss()

print("training...\n")

start = time.time()
optimizer = optim.Adam(rnn.parameters(), lr=0.0002)
rnn_hidden = rnn.initHidden()
rnn.zero_grad()
loss = 0
#for gata_q in range(int(n_iters/500)):
#    rnn_hidden = rnn.initHidden()

input_data,output_data=generate_data(n_iters)
for data_index in range(len(input_data)):
    input_tensor=torch.zeros(1, 1, 1)
    input_tensor[0][0][0]=input_data[data_index]

    output_tensor=torch.zeros(1, 1, 1)
    output_tensor[0][0][0]=output_data[data_index]

    rnn_output, rnn_hidden = rnn(Variable(input_tensor), rnn_hidden)
    loss += criterion(rnn_output, Variable(output_tensor))


    if data_index%2==0:
        loss.backward()

        total_loss_print += loss.data[0]
        total_loss_plot += loss.data[0]
        optimizer.step()
        rnn_hidden=Variable(rnn_hidden.data)
        rnn.zero_grad()
        loss = 0

    if data_index % print_every == 0:
        print('%s (%d %d%%) tl=%.4f' % (timeSince(start), data_index, data_index / n_iters * 100,total_loss_print/print_every))
        total_loss_print = 0

    if data_index % plot_every == 0:
        all_losses.append(total_loss_plot / plot_every)
        total_loss_plot = 0



import matplotlib.pyplot as plt
import matplotlib.ticker as ticker

plt.figure()
plt.plot(all_losses)
plt.show()

rnn_hidden = rnn.initHidden()

rnn.zero_grad()
loss = 0

rnn_output_data=[]
input_data,output_data=generate_data(1500)
for data_index in range(len(input_data)):
    input_tensor=torch.zeros(1, 1, 1)
    input_tensor[0][0][0]=input_data[data_index]
    rnn_output, rnn_hidden = rnn(Variable(input_tensor), rnn_hidden)
    rnn_output_data.append(rnn_output.data.numpy()[0][0][0])

plt.plot(input_data)#blue
plt.plot(output_data)#ogange
plt.plot(rnn_output_data)#green
plt.show()

Answer 1

我自己发现了问题。在某些情况下，问题是对最新数据的过度拟合，因为在强化学习的情况下，利用最新策略可能会发生过度拟合。由于我没有使用任何小批量并直接在新数据点之后应用优化器，并且由于数据点与 20-50 个样本相似，因此优化器仅将网络拟合到最新的点而忘记了之前的拟合。我通过收集50个点的梯度数据解决了这个问题，只有在它之后我才应用了一步优化器。网络现在可以更好地学习，但仍然不完美。

这里是修改代码使其工作：

rnn_output, rnn_hidden = rnn(Variable(input_tensor), rnn_hidden)

loss += criterion(rnn_output, Variable(output_tensor))

if data_index % 2==0:
    loss.backward()
    total_loss_print += loss.data[0]
    rnn_hidden=Variable(rnn_hidden.data)
    loss = 0
   # torch.nn.utils.clip_grad_norm(rnn.parameters(), 0.01)
if data_index % 50==0:
    optimizer.step()
    rnn.zero_grad()

积分学习的新成果： pic.