尝试索引全局变量'optim'(nil值)

require 'torch';
require 'nn';
require 'nnx';
mnist = require 'mnist';

fullset = mnist.traindataset()
testset = mnist.testdataset()
trainset = {
    size = 50000,
    data = fullset.data[{{1,50000}}]:double(),
    label = fullset.label[{{1,50000}}]
}
validationset = {
    size = 10000,
    data = fullset.data[{{50001, 60000}}]:double(),
    label = fullset.label[{{50001,60000}}]
}
-- MNIST 数据集有 28x28 张图片
model = nn.Sequential()

model:add(nn.SpatialConvolutionMM(1, 32, 5, 5))         -- 32x24x24
model:add(nn.ReLU())
model:add(nn.SpatialMaxPooling(3, 3, 3, 3))             -- 32x8x8

model:add(nn.SpatialConvolutionMM(32, 64, 5, 5))        -- 64x4x4
model:add(nn.Tanh())
model:add(nn.SpatialMaxPooling(2, 2, 2, 2))             -- 64x2x2
model:add(nn.Reshape(64*2*2))
model:add(nn.Linear(64*2*2, 200))
model:add(nn.Tanh())
model:add(nn.Linear(200, 10))

model:add(nn.LogSoftMax())

criterion = nn.ClassNLLCriterion()

x, dldx = model:getParameters()         -- 现在 x 存储可训练参数，dldx 存储模型中参数的梯度

sgd_params = {
   learningRate = 1e-2,
   learningRateDecay = 1e-4,
   weightDecay = 1e-3,
   momentum = 1e-4
}

step = function ( batchsize )

    -- 设置变量
    local count = 0
    local current_loss = 0
    local shuffle = torch.randperm(trainset.size)

    -- 把默认 batchsize 设置为 200
    batchsize = batchsize or 200

    -- 设置小批次的输入和输出
    for minibatch_number = 1, trainset.size, batchsize do

        local size = math.min( trainset.size - minibatch_number + 1, batchsize )
        local inputs = torch.Tensor(size, 28, 28)
        local targets = torch.Tensor(size)

        for index = 1, size do
            inputs[index] = trainset.data[ shuffle[ index + minibatch_number ]]
            targets[index] = trainset.label[ shuffle[ index + minibatch_number ] ]
        end

        -- 定义 feval 函数，返回损失和损失关于参数的梯度
        feval = function( x_new )
        --print ( "---------------------------------safe--------------------")

            if x ~= x_new then x:copy(x_new) end

            -- gradParsams 初始化为零
             dldx:zero()

            -- 计算损失和参数在梯度关于这些参数的损失
            local loss = criterion:forward( model.forward( inputs ), targets )
            model:backward( inputs, criterion:backward( model.output, targets ) )

            return loss, dldx
        end

        -- 获取损失
        -- optim 返回 x*, {fx}，其中 x* 是新的一系列参数，{fx} 是 { loss } => fs[ 1 ] 从 feval 中获取损失

        print(feval ~= nil and x ~= nil and sgd_params ~= nil)
        _,fs = optim.sgd(feval, x, sgd_params)

        count = count + 1
        current_loss = current_loss + fs[ 1 ]
    end

    -- 返回小批次的平均损失
    return current_loss / count

end

max_iters = 30

for i = 1 ,max_iters do
    local loss = step()
    print(string.format('Epoch: %d Current loss: %4f', i, loss))
end

我是 torch 和 lua 的新手，我找不到上面代码中的错误。有人能建议一种调试方法吗？

错误信息：

/home/afroz/torch/install/bin/luajit: /home/afroz/test.lua:88: attempt to index global 'optim' (a nil value)
stack traceback:
    /home/afroz/test.lua:88: in function 'step'
    /home/afroz/test.lua:102: in main chunk
    [C]: in function 'dofile'
    ...froz/torch/install/lib/luarocks/rocks/trepl/scm-1/bin/th:145: in main chunk
    [C]: at 0x00406670