LSTM modèle dans la flamme pas d'apprentissage

Question

I ont un ensemble de données de jouet avec une entrée et une sortie, les entrées sont 0 ou 1 s aléatoires et la sortie est égale à l'entrée à partir de 3 échantillons précédents

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

Modèle 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()) 

Modèle 2:

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

Critère:

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

Le premier modèle n'apprend pas et la seconde ne fonctionne pas (possible parce que mes données sont le mauvais type pour un Séquenceur?)

modifier:

Formation:

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 

Je reçois maintenant une erreur lors de l'exécution du modèle 2 grâce à la formation. L'erreur

AbstractRecurrent.lua: 61: Missing gradInput

se produit sur la ligne

lstm.modules [1]: backwardThroughTime()

Answer 1

regarder la exemple de jouet pour utiliser LSTM avec Sequencer. Le modèle ne fait rien sauf essayer de prédire des nombres aléatoires.

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