path: root/nerv/nn/network.lua

--- Implements the concept of computable but opaque networks built ("compiled")
-- from nested layers.
-- @author Qi Liu <liuq901@163.com>
-- @author Ted Yin <ted.sybil@gmail.com>

--- The class describing a computable but opaque network built from nested
-- layers.
-- @type nerv.Network

local network = nerv.class('nerv.Network')

--- The constructor.
-- @param id the identifier of the network (currently having no effects)
-- @param global_conf a table describing the computation state and providing
-- with some global settings
--
-- The following fields in `global_conf` will be used:
--
-- * `use_cpu`: whether to use CPU for the computation
-- * `mmat_type`: the class used for creating matrices in CPU computation
-- * `cumat_type` (if `use_cpu = false`): the class used for creating matrices
-- in GPU computation
--
-- The following fields in `global_conf` will be altered:
--
-- * `mask`: an array of `chunk_size` length containing column binary vectors
--   indicating whether each frame in a *batch matrix* (i.e. one matrix in a BPTT
--   chunk/"mini-batch") contains a valid data (1 indicates data, 0 indicates
--   holes)
--
-- @param network_conf a table providing with settings dedicated for the
-- network. Available fields includes:
--
-- * `network`: a `nerv.Layer` instance describing the structure of the network
--   to be compiled
-- * `clip`: a `number` value indicating the cliping threshold (i.e. preserve
--   the values within [-clip, +clip])
-- * `nn_act_default`: a `number` value indicating the value used for filling
--   "holes" in activation values of a batch matrix (0 by default)

function network:__init(id, global_conf, network_conf)
    self.id = id
    self.network = network_conf.network
    self.dim_in = self.network.dim_in
    self.dim_out = self.network.dim_out
    self.gconf = global_conf
    if self.gconf.use_cpu then
        self.mat_type = self.gconf.mmat_type
    else
        self.mat_type = self.gconf.cumat_type
    end
    self.clip = network_conf.clip
    self.nn_act_default = network_conf.nn_act_default
    if self.nn_act_default == nil then
        self.nn_act_default = 0
    end

    self.layers = {}
    self.input_conn = {}
    self.output_conn = {}
    self.socket = self:compile(self.network)
    for i = 1, #self.dim_in do
        local edge = self.socket.inputs[i]
        local id, port, time = edge[1], edge[2], edge[3]
        if self.input_conn[id][port] ~= nil then
            nerv.error('duplicate edge')
        end
        if nerv.is_type(self.layers[id], 'nerv.DuplicateLayer') then
            local tmp = nerv.IdentityLayer('', self.gconf, {dim_in = {self.dim_in[i]}, dim_out = {self.dim_in[i]}})
            table.insert(self.layers, tmp)
            local new_id = #self.layers
            self.input_conn[new_id] = {{0, i, time}}
            self.output_conn[new_id] = {{id, port, 0}}
            self.input_conn[id][port] = {new_id, 1, 0}
            self.socket.inputs[i] = {new_id, 1, time}
        else
            self.input_conn[id][port] = {0, i, time}
        end
    end
    for i = 1, #self.dim_out do
        local edge = self.socket.outputs[i]
        local id, port, time = edge[1], edge[2], edge[3]
        if self.output_conn[id][port] ~= nil then
            nerv.error('duplicate edge')
        end
        if nerv.is_type(self.layers[id], 'nerv.DuplicateLayer') then
            local tmp = nerv.IdentityLayer('', self.gconf, {dim_in = {self.dim_out[i]}, dim_out = {self.dim_out[i]}})
            table.insert(self.layers, tmp)
            local new_id = #self.layers
            self.input_conn[new_id] = {{id, port, 0}}
            self.output_conn[new_id] = {{0, i, time}}
            self.output_conn[id][port] = {new_id, 1, 0}
            self.socket.outputs[i] = {new_id, 1, time}
        else
            self.output_conn[id][port] = {0, i, time}
        end
    end

    self.delay = 0
    for i = 1, #self.layers do
        local dim_in, _ = self.layers[i]:get_dim()
        for j = 1, #dim_in do
            if self.input_conn[i][j] == nil then
                nerv.error('dangling input')
            end
            local time = self.input_conn[i][j][3]
            if math.abs(time) > self.delay then
                self.delay = math.abs(time)
            end
        end
    end

    self.input_edge = {}
    self.output_edge = {}
    for t = -self.delay, self.delay do
        self.input_edge[t] = {}
        self.output_edge[t] = {}
    end
    for i = 1, #self.layers do
        local dim_in, dim_out = self.layers[i]:get_dim()
        for j = 1, #dim_in do
            local time = self.input_conn[i][j][3]
            table.insert(self.input_edge[time], {i, j})
        end
        for j = 1, #dim_out do
            if self.output_conn[i][j] == nil then
                nerv.error('dangling output')
            end
            local time = self.output_conn[i][j][3]
            table.insert(self.output_edge[time], {i, j})
        end
    end
end

function network:compile(layer)
    local socket = {inputs = {}, outputs = {}}
    if not nerv.is_type(layer, 'nerv.GraphLayer') then
        table.insert(self.layers, layer)
        local id = #self.layers
        self.input_conn[id] = {}
        self.output_conn[id] = {}
        local dim_in, dim_out = layer:get_dim()
        for i = 1, #dim_in do
            socket.inputs[i] = {id, i, 0}
        end
        for i = 1, #dim_out do
            socket.outputs[i] = {id, i, 0}
        end
    else
        local sublayer_socket = {}
        for id, sublayer in pairs(layer.layers) do
            if id ~= '<input>' then
               sublayer_socket[sublayer.id] = self:compile(sublayer.layer)
            end
        end
        for _, edge in pairs(layer.connections) do
            -- id = 0 means <input> or <output>
            local id_from, port_from = edge[1], edge[2]
            local id_to, port_to = edge[3], edge[4]
            local time = edge[5]
            if id_from == 0 then
                if socket.inputs[port_from] ~= nil then
                    nerv.error('duplicate input socket')
                end
                local input = sublayer_socket[id_to].inputs[port_to]
                local id, port, t = input[1], input[2], input[3] + time
                socket.inputs[port_from] = {id, port, t}
            else
                local output = sublayer_socket[id_from].outputs[port_from]
                local id, port, t = output[1], output[2], output[3] + time
                if id_to == 0 then
                    if socket.outputs[port_to] ~= nil then
                        nerv.error('duplicate output socket')
                    end
                    socket.outputs[port_to] = {id, port, t}
                else
                    local input = sublayer_socket[id_to].inputs[port_to]
                    local id1, port1, t1 = input[1], input[2], input[3]
                    if self.input_conn[id1][port1] ~= nil or self.output_conn[id][port] ~= nil then
                        nerv.error('duplicate edge')
                    end
                    self.input_conn[id1][port1] = {id, port, t + t1}
                    self.output_conn[id][port] = {id1, port1, t + t1}
                end
            end
        end
    end
    return socket
end

--- Initialize the network for training.