require 'nn'

require 'rnn'

require 'image'

require 'optim'

require 'loader'

require 'ctc_log'

require 'utils/decoder'

local threads = require 'threads'

-- initialize

torch.setdefaulttensortype('torch.FloatTensor')

torch.manualSeed(450)

-- debug switch

DEBUG = false

-- timer initialize

base = 0

timer = torch.Timer()

function show_log(log)

end

-- settings

DROPOUT_RATE = 0.4

GPU_ENABLED = false

local input_size = 32

local hidden_size = 200

clamp_size = 5

-- configuration

training_list_file = "1.txt"

-- GPU

if GPU_ENABLED then

require 'cutorch'

require 'cunn'

end

-- load samples

show_log("Loading samples...")

local loader = Loader()

loader:load(training_list_file)

local codec = loader:codec()

show_log(string.format("Loading finished. Got %d samples, %d classes of characters.", #loader.samples, codec.codec_size))

local class_num = codec.codec_size

-- build network

show_log("Building networks...")

local net

net = nn.Sequential()

net:add(nn.Dropout(DROPOUT_RATE))

net:add(nn.SplitTable(1))

net:add(nn.BiSequencer(nn.FastLSTM(input_size, hidden_size)))

output = nn.Sequential()

output:add(nn.Linear(hidden_size * 2, class_num + 1))

output:add(nn.SoftMax())

net:add(nn.Sequencer(output))

net:float()

-- prepare prarmeters and training method

local params, grad_params

params, grad_params = net:getParameters()

n = net:sharedClone(true, false)

p, gd = n:getParameters()

local sample = loader:pick()

local im = sample.img

local target = codec:encode(sample.gt)

outputTable = n:forward(im)

loss, grad = ctc.getCTCCostAndGrad(outputTable, target)

n:backward(im, grad)