RNN不能学习积分函数

Question

为了研究深度学习，RNN、LSTM等尝试使RNN与集成函数相适应。我把随机信号从0到1作为RNN的输入，从偏置到-0.5的输入信号进行积分，使积分限制在0:1之间，并将其作为RNN的学习目标。蓝-随机输入，橙色-集成输入

因此，我有时间序列，只有一个输入(随机)和一个输出(输入的有限积分)，我希望RNN通过输入来预测输出。我使用Pytorch，尝试使用香草RNN，GRU单元，不同大小的隐藏层，堆叠几个RNN，将紧密连接的层放入RNN输出，不同深度的反向传播时间(从2到50梯度回滚)。我根本得不到好的结果！它在某种程度上起作用，但我找不到一种精确拟合积分函数的方法。这里是我最好的结果：绿色RNN输出。绿线(模型输出)在许多情况下不适合橙色线--这就是问题所在。

这是我在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()

以及积分学习的新结果：图片.