path: root/nerv/tnn/tnn.lua

local TNN = nerv.class("nerv.TNN")

local function parse_id(str)
    --used to parse layerid[portid],time
    local id, port, time, _
    _, _, id, port, time = string.find(str, "([a-zA-Z0-9_]+)%[([0-9]+)%][,]*([0-9]*)")
    if id == nil or port == nil then
        _, _, id, port, time = string.find(str, "(.+)%[([0-9]+)%][,]*([0-9]*)")
        if not (id == "<input>" or id == "<output>") then
            nerv.error("wrong format of connection id")
        end
    end
    --print(str, id, port, time)
    port = tonumber(port)
    if (time == nil) then
        time = 0
    else
        time = tonumber(time)
    end
    --now time don't need to be parsed
    return id, port
end

local function discover(id, layers, layer_repo)
    local ref = layers[id]
    if id == "<input>" or id == "<output>" then
        return nil
    end
    if ref == nil then
        local layer = layer_repo:get_layer(id)
        local dim_in, dim_out = layer:get_dim()
        ref = {
            layer = layer,
            id = layer.id,
            inputs_m = {}, --storage for computation, inputs_m[time][port]
            inputs_b = {}, --inputs_g[time][port], whether this input can been computed
            inputs_matbak_p = {}, --which is a back-up space to handle some cross-border computation, inputs_p_matbak[port]
            outputs_m = {},
            outputs_b = {},
            err_inputs_m = {},
            err_inputs_matbak_p = {}, --which is a back-up space to handle some cross-border computation
            err_inputs_b = {},
            err_outputs_m = {},
            err_outputs_b = {},
            i_conns_p = {}, --list of inputing connections
            o_conns_p = {}, --list of outputing connections
            dim_in = dim_in, --list of dimensions of ports
            dim_out = dim_out,
        }
        layers[id] = ref
    end
    return ref
end

nerv.TNN.FC = {} --flag const
nerv.TNN.FC.SEQ_START = 4
nerv.TNN.FC.SEQ_END = 8 
nerv.TNN.FC.HAS_INPUT = 1
nerv.TNN.FC.HAS_LABEL = 2
nerv.TNN.FC.SEQ_NORM = bit.bor(nerv.TNN.FC.HAS_INPUT, nerv.TNN.FC.HAS_LABEL) --This instance have both input and label

function TNN.make_initial_store(st, p, dim, batch_size, chunk_size, extend_t, global_conf, st_c, p_c, t_c)
    --Return a table of matrix storage from time (1-extend_t)..(chunk_size+extend_t)
    if (type(st) ~= "table") then
        nerv.error("st should be a table")
    end
    for i = 1 - extend_t - 2, chunk_size + extend_t + 2 do --intentionally allocated more time
        if (st[i] == nil) then
            st[i] = {}
        end
        st[i][p] = global_conf.cumat_type(batch_size, dim)
        st[i][p]:fill(0)
        if (st_c ~= nil) then
            if (st_c[i + t_c] == nil) then
                st_c[i + t_c] = {}
            end
            st_c[i + t_c][p_c] = st[i][p]
        end
    end
    collectgarbage("collect") --free the old one to save memory
end

function TNN:out_of_feedrange(t) --out of chunk, or no input, for the current feed
    if (t < 1 or t > self.chunk_size) then
        return true
    end
    if (self.feeds_now.flagsPack_now[t] == 0 or self.feeds_now.flagsPack_now[t] == nil) then
        return true
    end
    return false
end

function TNN:__init(id, global_conf, layer_conf)
    self.clip_t = layer_conf.clip_t
    if self.clip_t == nil then
        self.clip_t = 0
    end
    if self.clip_t > 0 then
        nerv.info("tnn(%s) will clip gradient across time with %f...", id, self.clip_t)
    end

    self.extend_t = layer_conf.extend_t --TNN will allocate storage of time for 1-extend_t .. chunk_size+extend_t
    if self.extend_t == nil then
        self.extend_t = 5 
    end
    nerv.info("tnn(%s) will extend storage beyond MB border for time steps %d...", id, self.extend_t)

    local layers = {}
    local inputs_p = {} --map:port of the TNN to layer ref and port
    local outputs_p = {}
    local dim_in = layer_conf.dim_in
    local dim_out = layer_conf.dim_out
    local parsed_conns = {}
    local _
    
    for id, layer in pairs(layer_conf.sub_layers.layers) do
        discover(id, layer, layer_conf.sub_layers)
    end

    for _, ll in pairs(layer_conf.connections) do
        local id_from, port_from = parse_id(ll[1])
        local id_to, port_to = parse_id(ll[2])
        local time_to = ll[3] 

        print(id_from, id_to, time_to)

        local ref_from = discover(id_from, layers, layer_conf.sub_layers)
        local ref_to = discover(id_to, layers, layer_conf.sub_layers)
        
        if (id_from == "<input>") then
            if (dim_in[port_from] ~= ref_to.dim_in[port_to] or time_to ~= 0) then
                nerv.error("mismatch dimension or wrong time %s,%s,%d", ll[1], ll[2], ll[3])
            end
            inputs_p[port_from] = {["ref"] = ref_to, ["port"] = port_to}          
            ref_to.inputs_m[port_to] = {} --just a place holder
        elseif (id_to == "<output>") then
            if (dim_out[port_to] ~= ref_from.dim_out[port_from] or time_to ~= 0) then
                nerv.error("mismatch dimension or wrong time %s,%s,%d", ll[1], ll[2], ll[3])
            end
            outputs_p[port_to] = {["ref"] = ref_from, ["port"] = port_from}
            ref_from.outputs_m[port_from] = {} --just a place holder
        else
            local conn_now = { 
                ["src"] = {["ref"] = ref_from, ["port"] = port_from},
                ["dst"] = {["ref"] = ref_to, ["port"] = port_to},
                ["time"] = time_to
            }
            if (ref_to.dim_in[port_to] ~= ref_from.dim_out[port_from]) then
                nerv.error("mismatch dimension or wrong time %s,%s,%d", ll[1], ll[2], ll[3])
            end
            table.insert(parsed_conns, conn_now)
            ref_to.i_conns_p[conn_now.dst.port] = conn_now
            ref_from.o_conns_p[conn_now.src.port] = conn_now
        end
    end

    for id, ref in pairs(layers) do
        print(id, "#dim_in:", #ref.dim_in, "#dim_out:", #ref.dim_out, "#i_conns_p:", #ref.i_conns_p, "#o_conns_p", #ref.o_conns_p)
    end

    self.layers = layers
    self.inputs_p = inputs_p
    self.outputs_p = outputs_p
    self.id = id
    self.dim_in = dim_in
    self.dim_out = dim_out
    self.parsed_conns = parsed_conns
    self.gconf = global_conf
end

function TNN:init(batch_size, chunk_size)
    self.batch_size = batch_size
    self.chunk_size = chunk_size
    for i, conn in ipairs(self.parsed_conns) do --init storage for connections inside the NN
        local _, output_dim
        local ref_from, port_from, ref_to, port_to, time
        ref_from, port_from = conn.src.ref, conn.src.port
        ref_to, port_to = conn.dst.ref, conn.dst.port
        time = conn.time

        local dim = ref_from.dim_out[port_from]
        if (dim == 0) then
            nerv.error("layer %s has a zero dim port", ref_from.layer.id)
        end

        nerv.info("TNN initing storage %s->%s", ref_from.layer.id, ref_to.layer.id)
        ref_to.inputs_matbak_p[port_to] = self.gconf.cumat_type(batch_size, dim)
        self.make_initial_store(ref_from.outputs_m, port_from, dim, batch_size, chunk_size, self.extend_t, self.gconf, ref_to.inputs_m, port_to, time)
        ref_from.err_inputs_matbak_p[port_from] =  self.gconf.cumat_type(batch_size, dim)
        self.make_initial_store(ref_from.err_inputs_m, port_from, dim, batch_size, chunk_size, self.extend_t, self.gconf, ref_to.err_outputs_m, port_to, time)
    end

    self.outputs_m = {}
    self.err_inputs_m = {}
    for i = 1, #self.dim_out do --Init storage for output ports 
        local ref = self.outputs_p[i].ref
        local p = self.outputs_p[i].port
        self.make_initial_store(ref.outputs_m, p, self.dim_out[i], batch_size, chunk_size, self.extend_t, self.gconf, self.outputs_m, i, 0)