LSTM Модель в факел не Изучение

Question

У меня есть игрушка набор данных с одним входом и одним выходом, входы являются случайными 0s или 1s, а выход равен вход от 3 образцов предыдущих

Input, Output 
0,1 
1,1 
0,0 
1,0 
0,1 
0,0 

Model 1:

lstm = nn.Sequential() 
lstm:add(nn.LSTM(1,20,8)) 
lstm:add(nn.Linear(20,100)) 
lstm:add(nn.Sigmoid()) 
lstm:add(nn.Linear(100,1)) 
lstm:add(nn.Sigmoid()) 

Модель 2:

lstm = nn.Sequencer(
    nn.Sequential() 
     :add(nn.LSTM(1,100)) 
     :add(nn.Linear(100,1)) 
     :add(nn.Sigmoid()) 
    ) 

Критерий:

criterion = nn.BCECriterion() 
trainer = nn.StochasticGradient(lstm, criterion) 
trainer.learningRate = .01 
trainer.maxIteration = 25 

Первая модель не учит, а второй не работает (возможно потому, что мои данные неправильный вид на секвенсор?)

редактировать:

Обучение:

lstm:training() 
print("Training") 
for epoch=1, 5 do 
    err = 0 
    for i = 1,data:size() do 
    input = {} 
    output = {} 
    table.insert(input, data[i][1]) 
    table.insert(output, data[i][2]) 
    --input = data[i][1] 
    --output = data[i][2] 
    err = err + criterion:forward(lstm:updateOutput(input)[1], output) 
    lstm:zeroGradParameters() 
    lstm:backward(input, {criterion:backward(lstm.output[1], output)}) 
    lstm.modules[1]:backwardThroughTime() 
    lstm:updateParameters(0.01) 
    lstm.modules[1]:forget() 
    end 
    print (err/data:size()) 
end 

Теперь я получаю сообщение об ошибке при запуске модели 2 через обучение. Ошибка

AbstractRecurrent.lua: 61: Отсутствует gradInput

происходит на линии

lstm.modules [1]: backwardThroughTime()

Answer 1

взгляд на пример игрушки для использования LSTM с секвенсером. Модель не делает ничего, кроме как попытаться предсказать случайные числа.

require 'nn' 
require 'torch' 
require 'rnn' 

lstm = nn.Sequencer(
    nn.Sequential() 
     :add(nn.LSTM(1,100)) 
     :add(nn.Linear(100,1)) 
     :add(nn.Sigmoid()) 
    ) 

-- Encapsulate thr criterion using a Sequencer 
-- Just provide the entire sequence as input and the corresponding 
-- target sequence as expected output 
criterion = nn.SequencerCriterion(nn.BCECriterion()) 

data = torch.zeros(10,2) 
for i=1,data:size(1) do 
    data[i][1] = torch.uniform() 
    data[i][2] = torch.uniform() 
end 

local inputs, targets = {},{} 

for epoch=1,5 do 
    lstm:training() 

    for i=1,data:size(1) do 
    --useful for minibatch 
    inputs[1] = torch.zeros(1) 
    inputs[1][1] = data[i][1] 

    targets[1] = torch.zeros(1) 
    targets[1][1] = data[i][2] 

    local output = lstm:forward(inputs) 
    local err = criterion:forward(output, targets) 

    local gradOutputs = criterion:backward(output, targets) 
    -- Sequencer handles the backwardThroughTime internally 
    lstm:backward(inputs, gradOutputs) 
    lstm:updateParameters(0.01) 
    lstm:zeroGradParameters() 

    inputs = {} 
    targets = {} 
    end 
end