[submodule "luajit-2.0"]

path = luajit-2.0

[submodule "luarocks"]

path = luarocks

.PHONY: all clean install luajit luarocks speech

SHELL := /bin/bash

PREFIX := $(CURDIR)/install/

luajit:

PREFIX=$(PREFIX) ./tools/build_luajit.sh

luarocks:

PREFIX=$(PREFIX) ./tools/build_luarocks.sh

.PHONY: build install clean

SHELL := /bin/bash

INC_PATH := $(LUA_BINDIR)/../include/nerv

LUA_DIR = $(INST_LUADIR)/nerv

OBJ_DIR := $(BUILD_DIR)/objs

SUBDIR := matrix io layer examples nn tnn lib/io lib/luaT lib/matrix

INC_SUBDIR := $(addprefix $(INC_PATH)/,$(ISUBDIR))

OBJ_SUBDIR := $(addprefix $(OBJ_DIR)/,$(SUBDIR))

LUA_SUBDIR := $(addprefix $(LUA_DIR)/,$(SUBDIR))

CORE_OBJS := lib/common.o lib/io/chunk_file.o \

lib/matrix/mmatrix.o lib/matrix/cumatrix.o lib/matrix/cukernel.o

NERV_OBJS := nerv.o \

layer/init.lua layer/affine.lua layer/sigmoid.lua layer/tanh.lua layer/softmax_ce.lua layer/softmax.lua \

layer/window.lua layer/bias.lua layer/combiner.lua layer/mse.lua \

layer/elem_mul.lua layer/lstm.lua layer/lstm_gate.lua layer/dropout.lua layer/gru.lua \

INCLUDE := -I $(LUA_INCDIR) -DLUA_USE_APICHECK

CUDA_INCLUDE := -I $(CUDA_BASE)/include/

INCLUDE += $(CUDA_INCLUDE)

NVCC := $(CUDA_BASE)/bin/nvcc

EMPTY :=

SPACE := $(EMPTY) $(EMPTY)

cp $< $@

$(LIB_PATH)/libnervcore.so: $(CORE_OBJS)

$(LIB_PATH)/libluaT.so: $(LUAT_OBJS)

$(INST_LIBDIR)/libnerv.so: $(NERV_OBJS) $(LIB_PATH)/libnervcore.so $(LIB_PATH)/libluaT.so

$(OBJ_DIR)/matrix/cumatrix.o: matrix/generic/cumatrix.c matrix/generic/matrix.c

$(OBJ_DIR)/matrix/mmatrix.o: matrix/generic/mmatrix.c matrix/generic/matrix.c

install: $(LIBS) $(LUA_DIR) $(LUA_SUBDIR) $(LUA_LIBS) $(INC_SUBDIR) $(INCS)

cp $< $@

Part of the [Nerv](../README.md) toolkit.

* __string = nerv.typename(obj a)__

A registered function, the original function is `luaT_lua_typename`. In some cases if you call `type(a)` for object of some class in __Nerv__(like __Nerv.CuMatrix__) it will only return "userdata"(because it is created in C), in this case you can use this method to get its type.

* __string = nerv.setmetatable(table self, string tname)__

A registered function, the original function is `luaT_lua_setmetatable`. It assigns the metatable registered in __luaT__ by the name *tname* to the table *self*. And return *tname* to user.

* __table = nerv.get_type(string typename)__

Part of the [Nerv](../README.md) toolkit.

* __metatable mt, metatable mpt = nerv.class(string tname, string parenttname)__

This method is used to create a class by the name `tname`, which inherits `parenttname` in __Nerv__, then you create a new instance of this class by calling `obj=tname(...)`. The `tname.__init(...)` method(if defined) will be called in the constructing. The metatable of the class and its parent class will be returned.

* This example implements a simple `nerv.Counter` class which is inherited by `nerv.BetterCounter`.

```

print(c1.c)

bc1 = nerv.BetterCounter(1, 1)

print(bc1.c, bc1.bc)

Part of the [Nerv](../README.md) toolkit.

The main class that the user uses to store and read parameter object to and from files is __nerv.ChunkFile__.

In the file, a parameter object will be saved using a standard format. First is the length(in byte) of this object, then a table which includes some meta information of the object, and a data area. Below is an example text file.

```

3.000000 3.000000 3.000000

```

* __ChunkFile ChunkFile(string fn, string mode)__

`mode` can be `r` or `w`, for reading or writing a file. The returned __ChunkFile__ will be ready to write or read objects which follows the __nerv.Param__ interface(using `write_chunk` and `read_chunk`).

* __void ChunkFile.write_chunk(ChunkFile self, Param p)__

* __void ChunkFile.close(ChunkFile self)__

Close the opened file.

* An example showing how to use __ChunkFile__ to store and read parameter objects.

```

require 'io'

end

```

* There are four classes in to deal with chunk data, which are __nerv.ChunkFile__, __nerv.ChunkFileHandle__, __nerv.ChunkInfo__, __nerv.ChunkData__. Below is the underlying C structs.

```

typedef struct ChunkFileHandle {

char *data;

} ChunkData;

```

Part of the [Nerv](../README.md) toolkit.

__nerv.Layer__ is the base class and most of its methods are abstract.

* __nerv.Layer__.

* `table dim_in` It specifies the dimensions of the inputs.

* `table dim_out` It specifies the dimensions of the outputs.

* `int total_frams` Records how many frames have passed.

* `bool compressed` The reference distribution can be a one-hot format. This feature is enabled by `layer_conf.compressed`.

* __void Layer.\_\_init(Layer self, string id, table global_conf, table layer_conf)__

Abstract method.

The constructing method should assign `id` to `self.id` and `global_conf` to `self.gconf`, `layer_conf.dim_in` to `self.dim_in`, `layer_conf.dim_out` to `self.dim_out`. `dim_in` and `dim_out` are a list specifies the dimensions of the inputs and outputs. Also, `layer_conf` will include the parameters, which should also be properly saved.

Abstract method.

The layer should return a list containing its parameters.

* Returns:

`dim_in`: __table__.

`dim_out`: __table__.

* Description:

Returns `self.dim_in, self.dim_out`.

* a basic example using __Nerv__ layers to a linear classification.

```

end

--[[end training]]--

```

Part of the [Nerv](../README.md) toolkit.

In the begining is could be useful to know something about the underlying structure of a __Nerv__ matrix. Please keep in mind that matrice in __Nerv__ is row-major.

Every matrix object is a encapsulation of a C struct that describes the attributes of this matrix.

```

It is worth mentioning that that `data_ref` is a counter which counts the number of references to its memory space, mind that it will also be increased when a row of the matrix is referenced(`col = m[2]`). A __Nerv__ matrix will deallocate its space when this counter is decreased to zero.

Also note that all assigning operation in __Nerv__ is reference copy, you can use `copy_tod` or `copy_toh` method to copy value. Also, row assigning operations like `m1[2]=m2[3]` is forbidden in __Nerv__.

The class hierarchy of the matrix classes can be clearly observed in `matrix/init.c`.

First there is a abstract base class __Nerv.Matrix__, which is inherited by __Nerv.CuMatrix__ and __Nerv.MMatrix__(also abstract).

Finally, there is __Nerv.CuMatrixFloat__, __Nerv.CuMatrixDouble__, inheriting __Nerv.CuMatrix__, and __Nerv.MMatrixFloat__, __Nerv.MMatrixDouble__, __Nerv.MMatrixInt__ , inheriting __Nerv.MMatrix__.

Mind that usually a matrix object can only do calculation with matrix of its own type(a __Nerv.CuMatrixFloat__ matrix can only do add operation with a __Nerv.CuMatrixFloat__).

In the methods description below, __Matrix__ could be __Nerv.CuMatrixFloat__, __Nerv.CuMatrixDouble__, __Nerv.MMatrixFloat__ or __Nerv.MMatrixDouble__. __Element_type__ could be `float` or `double`, respectively.

* __Matrix = Matrix(int nrow, int ncol)__

Return a new __Matrix__ of size (`self.nrow`,1), which stores the sum of all rows of __Matrix__ `self`.

* __Matrix Matrix.rowmax(Matrix self)__

Return a new __Matrix__ of size (`self.nrow`,1), which stores the max value of all rows of __Matrix__ `self`.

* __Matrix Matrix.trans(Matrix self)__

Return a new __Matrix__ of size (`self.ncol`,`self.nrow`), which stores the transpose of __Matrix__ `self`.

* __void Matrix.copy_fromh(Matrix self, MMatrix a)__

Set the element of __Matrix__ `self` to be elementwise-sigmoid of `ma`.

* __void Matrix.sigmoid_grad(Matrix self, Matrix err, Matrix output)__

Set the element of __Matrix__ `self`, to be `self[i][j]=err[i][j]*output[i][j]*(1-output[i][j])`. This function is used to propagate sigmoid layer error.

* __void Matrix.mul_elem(Matrix self, Matrix ma, Matrix mb)__

Calculate element-wise multiplication of __Matrix__ `ma` and `mb`, store the result in `self`.

* __void Matrix.log_elem(Matrix self, Matrix ma)__

* __void MMatrix.copy_from(MMatrix ma, MMatrix mb,[int b_bgein, int b_end, int a_begin])__

Copy a part of `mb`(rows of index `[b_begin..b_end)`) to `ma` beginning at row index `a_begin`. If not specified, `b_begin` will be `0`, `b_end` will be `b.nrow`, `a_begin` will be `0`.

* Use `get_dataref_value` to test __Nerv__'s matrix space allocation.

```

m = 10

print(fm)

print(dm)

```

* Test some __Matrix__ calculations.

```

m = 4

a:log_elem(fs)

print(a)

```

Part of the [Nerv](../README.md) toolkit.

it contains __nerv.LayerRepo__, __nerv.ParamRepo__, and __nerv.DAGLayer__(inherits __nerv.Layer__).

Get parameter object by ID.

* `table param_table` Contains the mapping of parameter ID to parameter file(__nerv.ChunkFile__)

* __nerv.LayerRepo__ Get layer object by ID.

* `table layers` Contains the mapping of layer ID to layer object.

objects.

Inherits __nerv.Layer__.

* `layers`: __table__, a mapping from a layer ID to its "ref". A ref is a structure that contains reference to space allocations and other info of the layer.

* `inputs`: __table__, a mapping from the inputs ports of the DAG layer to the input ports of the sublayer, the key is the port number, the value is `{ref, port}`.

* `parsed_conn`: __table__, a list of parsed connections, each entry is of format `{{ref_from, port_from}, {ref_to, port_to}}`.

* `queue`: __table__, a list of "ref"s, the propagation of the DAGLayer will follow this order, and back-propagation will follow a reverse order.

* Parameters:

`param_files`: __table__

* Description:

`param_files` is a list of file names that stores parameters, the newed __ParamRepo__ will read them from file and store the mapping for future fetching.

* Returns:

__nerv.Layer__

* Parameters:

* Description:

__ParamRepo__ will find the __nerv.ChunkFile__ `pf` that contains parameter of ID `pid` and return `pf:read_chunk(pid, global_conf)`.

* Returns:

__nerv.LayerRepo__.

* Parameters:

__LayerRepo__ will merge `param_config` into `layer_config` and construct a layer by calling `layer_type(layerid, global_conf, layer_config)`.

* Returns:

__nerv.LayerRepo__, the layer with ID `lid`.

* Parameters:

* Description:

Returns the layer with ID `lid`.

* Returns:

__nerv.DAGLayer__

* Parameters:

}})

```

* Parameters:

`self`: __nerv.DAGLayer__

`batch_size`: __int__

This initialization method will allocate space for output and input matrice, and will call `init()` for each of its sub layers.

* Parameters:

`self`: __nerv.DAGLayer__

`input`: __table__

* Description:

The same function as __nerv.Layer.propagate__, do propagation for each layer in the order of `self.queue`.

* Parameters:

`self`: __nerv.DAGLayer__

`next_bp_err`: __table__

* Description:

The same function as __nerv.Layer.back_propagate__, do back-propagation for each layer in the reverse order of `self.queue`.

* Parameters:

`self`: __nerv.DAGLayer__

`bp_err`: __table__

* Description:

The same function as __nerv.Layer.update__, do update for each layer in the order of `self.queue`.

* aaa

```

ce_last = softmaxL.total_ce

end

--[[end training]]--

Part of the [Nerv](../README.md) toolkit.

There is a base class __Nerv.Param__ defined in `layer/init.lua`.

* __nerv.MatrixParam__ inherits __nerv.Param__

* `Matrix trans` stores the parameter matrix.

* __nerv.LinearTransParam__ inherits __Nerv.MatrixParam__.

* __Nerv.BiasParam__ inherits __Nerv.MatrixParam__.

* __void Param.\_\_init(Param self, string id, table global_conf)__

Constructor of a __Param__, it will set `self.id` to be `id` and `self.gconf` to be `global_conf`.

* __void Param.set_info(Param self, table info)__

local mat_type

if gconf.use_cpu then

mat_type = gconf.mmat_type

else

mat_type = gconf.cumat_type

end

gconf.randomize = bp

-- build buffer

local buffer = make_buffer(make_readers(scp_file, layer_repo))

-- initialize the network

gconf.cnt = 0

err_input = {mat_type(gconf.batch_size, 1)}

err_input[1]:fill(1)

for data in buffer.get_data, buffer do

-- prine stat periodically

gconf.cnt = gconf.cnt + 1

for i = 1, #input do

table.insert(err_output, input[i]:create())

end

if bp then

end

-- collect garbage in-time to save GPU memory

collectgarbage("collect")

print_stat(layer_repo)

mat_type.print_profile()

mat_type.clear_profile()

end

end

return iterative_trainer

end

end

end

end

end

-- nerv.Matrix.print_profile()

end

require 'htk_io'

gconf = {lrate = 0.8, wcost = 1e-6, momentum = 0.9,

rearrange = true, -- just to make the context order consistent with old results, deprecated

frm_ext = 5,

frm_trim = 5, -- trim the first and last 5 frames, TNet just does this, deprecated

cv_scp = "/slfs1/users/mfy43/swb_ivec/train_cv.scp",

htk_conf = "/slfs1/users/mfy43/swb_ivec/plp_0_d_a.conf",

initialized_param = {"/slfs1/users/mfy43/swb_init.nerv",

function make_layer_repo(param_repo)

local layer_repo = nerv.LayerRepo(

-- global transf

["nerv.BiasLayer"] =

{

},

["nerv.WindowLayer"] =

{

},

-- biased linearity

["nerv.AffineLayer"] =

{

},

["nerv.SigmoidLayer"] =

{

},

["nerv.SoftmaxCELayer"] = -- softmax + ce criterion layer for finetune output

{

},

["nerv.SoftmaxLayer"] = -- softmax for decode output

{

}

}, param_repo, gconf)

{

["nerv.DAGLayer"] =

{

dim_in = {429}, dim_out = {429},

sub_layers = layer_repo,

connections = {

["blayer2[1]"] = "wlayer2[1]",

["wlayer2[1]"] = "<output>[1]"

}

dim_in = {429}, dim_out = {3001},

sub_layers = layer_repo,

connections = {

["sigmoid6[1]"] = "affine7[1]",

["affine7[1]"] = "<output>[1]"

}

}

}, param_repo, gconf)

{

["nerv.DAGLayer"] =

{

dim_in = {429, 1}, dim_out = {1},

sub_layers = layer_repo,

connections = {

["<input>[2]"] = "ce_crit[2]",

["ce_crit[1]"] = "<output>[1]"

}

dim_in = {429}, dim_out = {3001},

sub_layers = layer_repo,

connections = {

["main[1]"] = "softmax[1]",

["softmax[1]"] = "<output>[1]"

}

}

}, param_repo, gconf)

return nerv.SGDBuffer(gconf,

{

buffer_size = gconf.buffer_size,

randomize = gconf.randomize,

readers = readers,

use_gpu = true

{id = "phone_state"}}

end

function get_accuracy(layer_repo)

local ce_crit = layer_repo:get_layer("ce_crit")

return ce_crit.total_correct / ce_crit.total_frames * 100

nerv.error("method not implemented");

end

--- Format a string just like `sprintf` in C.

-- @param fmt the format string

-- @param ... args, the data to be formatted

-- @param fmt the format string

-- @param ... args, the data to be formatted

function nerv.printf(fmt, ...)

end

--- Raise an global error with the formatted message.

end

function table.val_to_str(v)

end

end

function table.key_to_str (k)

end

--- Get the string representation of a table, which can be executed as a valid

-- @return the string representation which will result in a Lua table entity

-- when evaluated

function table.tostring(tbl)

end

end

--- Get the class by name.

return dofile(nerv.dirname(caller) .. filename)

end

-- the following lines trigger the initialization of basic modules

nerv.include('matrix/init.lua')

nerv.include('io/init.lua')

nerv.include('layer/init.lua')

nerv.include('nn/init.lua')

nerv.error_method_not_implemented()

end

nerv.error_method_not_implemented()

end

nerv.include('sgd_buffer.lua')

function SGDBuffer:__init(global_conf, buffer_conf)

self.gconf = global_conf

self.buffer_size = math.floor(buffer_conf.buffer_size /

self.randomize = buffer_conf.randomize

self.consume = buffer_conf.consume

local cumat_type = global_conf.cumat_type

end

self.rand_map = self.perm_gen(self.tail) -- generate shuffled index

collectgarbage("collect")

end

function SGDBuffer:get_data()

if self.head >= self.tail then -- buffer is empty

local t = os.clock()

if (not self:saturate()) and (not self.consume) then

--- A parameter that consists of a single matrix

-- @type nerv.MatrixParam

--- Read from a file handle.

-- @param handle the file handle

function MatrixParam:read(handle)

self.trans = self.gconf.mmat_type.load(handle)

end

function MatrixParam:write(handle)

end

function MatrixParam:train_init()

self.correction:fill(0)

end

function MatrixParam:_update_by_gradient(gradient, alpha, beta)

local gconf = self.gconf

-- momentum gain

--- The constructor.

function AffineLayer:__init(id, global_conf, layer_conf)

for i = 1, #self.dim_in do

local pid = "ltp" .. i

local pid_list = i == 1 and {pid, "ltp"} or pid

nerv.LinearTransParam,

end

self.ltp = self.ltp1 -- alias of ltp1

nerv.BiasParam,

{1, self.dim_out[1]})

end

function AffineLayer:init(batch_size)

end

function AffineLayer:get_params()

for i = 2, #self.dim_in do

pr:add(self["ltp" .. i].id, self["ltp" .. i])

end

local BiasLayer = nerv.class("nerv.BiasLayer", "nerv.Layer")

function BiasLayer:__init(id, global_conf, layer_conf)

self:check_dim_len(1, 1)

end

function BiasLayer:init()

end

function BiasLayer:get_params()

end

local CombinerLayer = nerv.class('nerv.CombinerLayer', 'nerv.Layer')

function CombinerLayer:__init(id, global_conf, layer_conf)

self.lambda = layer_conf.lambda

self:check_dim_len(#self.lambda, -1)

if #self.dim_in < 1 then

nerv.error("no input specified")

end

end

function CombinerLayer:init(batch_size)

local dim = self.dim_in[1]

for i = 2, #self.dim_in do

end

function CombinerLayer:get_params()

end

local DropoutLayer = nerv.class("nerv.DropoutLayer", "nerv.Layer")

function DropoutLayer:__init(id, global_conf, layer_conf)

nerv.warning("[DropoutLayer:propagate] dropout rate is not set")

end

self:check_dim_len(1, 1) -- two inputs: nn output and label

end

function DropoutLayer:init(batch_size, chunk_size)

if self.dim_in[1] ~= self.dim_out[1] then

nerv.error("mismatching dimensions of input and output")

if t == nil then

t = 1

end

self.mask[t]:rand_uniform()

-- since we will lose a portion of the actvations, we multiply the

-- activations by 1 / (1 - rate) to compensate

output[1]:mul_elem(input[1], self.mask[t])

else

output[1]:copy_fromd(input[1])

if t == nil then

t = 1

end

next_bp_err[1]:mul_elem(bp_err[1], self.mask[t])

else

next_bp_err[1]:copy_fromd(bp_err[1])

end

function DropoutLayer:get_params()

end

local ElemMulLayer = nerv.class('nerv.ElemMulLayer', 'nerv.Layer')

function ElemMulLayer:__init(id, global_conf, layer_conf)

-- element-wise multiplication of input[1] and input[2]

self:check_dim_len(2, 1)

end

function ElemMulLayer:init(batch_size)

if self.dim_in[1] ~= self.dim_in[2] or

self.dim_in[1] ~= self.dim_out[1] then

end

function ElemMulLayer:get_params()

end

-- input1:x

-- input2:h

-- input3:c (h^~)

if self.dim_in[2] ~= self.dim_out[1] then

nerv.error("dim_in[2](%d) mismatch with dim_out[1](%d)",

self.dim_in[2], self.dim_out[1])

-- prepare a DAGLayer to hold the lstm structure

local pr = layer_conf.pr

if pr == nil then

end

local function ap(str)

},

}

local connections = {

["<input>[1]"] = ap("inputXDup[1]"),

self.dag = nerv.DAGLayer(self.id, global_conf,

{dim_in = self.dim_in,

dim_out = self.dim_out,

connections = connections})

self:check_dim_len(2, 1) -- x, h and h

end

function GRULayer:init(batch_size, chunk_size)

self.dag:init(batch_size, chunk_size)

end

local Layer = nerv.class('nerv.Layer')

function Layer:__init(id, global_conf, layer_conf)

end

function Layer:init(batch_size)

nerv.error_method_not_implemented()

end

function Layer:get_dim()

return self.dim_in, self.dim_out

end

end

end

end

end

if type(gconf.param_random) ~= "function" then

nerv.error("a param generate function is needed")

end

return p

end

nerv.include('affine.lua')

nerv.include('sigmoid.lua')

nerv.include('tanh.lua')

nerv.include('lstm_gate.lua')

nerv.include('dropout.lua')

nerv.include('gru.lua')

-- The following lines are for backward compatibility, and will be removed in

-- the future. The use of these names are deprecated.

function LSTMLayer:__init(id, global_conf, layer_conf)

local pr = layer_conf.pr

if pr == nil then

end

},

},

},

},

},

}

local connections = {

}

end

-- NOTE: this is a full matrix gate

function LSTMGateLayer:__init(id, global_conf, layer_conf)

self.param_type = layer_conf.param_type

for i = 1, #self.dim_in do

nerv.LinearTransParam,

{self.dim_in[i], self.dim_out[1]})

if self.param_type[i] == 'D' then

self["ltp" .. i].trans:diagonalize()

end

end

nerv.BiasParam, {1, self.dim_out[1]})

end

function LSTMGateLayer:init(batch_size)

end

function LSTMGateLayer:get_params()

for i = 1, #self.dim_in do

pr:add(self["ltp" .. i].id, self["ltp" .. i])

end

local MSELayer = nerv.class("nerv.MSELayer", "nerv.Layer")

function MSELayer:__init(id, global_conf, layer_conf)

self:check_dim_len(2, -1)

end

function MSELayer:init(batch_size)

if self.dim_in[1] ~= self.dim_in[2] then

nerv.error("mismatching dimensions of previous network output and labels")

end

function MSELayer:get_params()

end

local SigmoidLayer = nerv.class("nerv.SigmoidLayer", "nerv.Layer")

function SigmoidLayer:__init(id, global_conf, layer_conf)

self:check_dim_len(1, 1)

if self.dim_in[1] ~= self.dim_out[1] then

nerv.error("mismatching dimensions of input and output")

end

end

function SigmoidLayer:batch_resize(batch_size)

-- do nothing

end

end

function SigmoidLayer:get_params()

end

local SoftmaxLayer = nerv.class("nerv.SoftmaxLayer", "nerv.Layer")

function SoftmaxLayer:__init(id, global_conf, layer_conf)

self:check_dim_len(1, 1) -- two inputs: nn output and label

end

function SoftmaxLayer:init(batch_size)

if self.dim_in[1] ~= self.dim_out[1] then

nerv.error("mismatching dimensions of input and output")

end

function SoftmaxLayer:get_params()

end

local SoftmaxCELayer = nerv.class("nerv.SoftmaxCELayer", "nerv.Layer")

function SoftmaxCELayer:__init(id, global_conf, layer_conf)

self.compressed = layer_conf.compressed

if self.compressed == nil then

self.compressed = false

self:check_dim_len(2, -1) -- two inputs: nn output and label

end

function SoftmaxCELayer:init(batch_size, chunk_size)

if not self.compressed and (self.dim_in[1] ~= self.dim_in[2]) then

nerv.error("mismatching dimensions of previous network output and labels")

end

function SoftmaxCELayer:get_params()

end

local TanhLayer = nerv.class("nerv.TanhLayer", "nerv.Layer")

function TanhLayer:__init(id, global_conf, layer_conf)

self:check_dim_len(1, 1)

end

function TanhLayer:init()

if self.dim_in[1] ~= self.dim_out[1] then

nerv.error("mismatching dimensions of input and output")

end

function TanhLayer:get_params()

end

local WindowLayer = nerv.class("nerv.WindowLayer", "nerv.Layer")

function WindowLayer:__init(id, global_conf, layer_conf)

self:check_dim_len(1, 1)

end

function WindowLayer:init()

end

function WindowLayer:get_params()

end

va_list ap;

va_start(ap, err_mesg_fmt);

lua_pushstring(L, "[nerv] internal error: ");

lua_concat(L, 2);

lua_error(L);

va_end(ap);

}

}

HashMap *res = (HashMap *)malloc(sizeof(HashMap));

res->bucket = calloc(size, sizeof(HashNode));

res->cmp = cmp;

return res;

}

size_t idx = h->hfunc(key) % h->size;

HashNode *ptr;

for (ptr = h->bucket[idx]; ptr; ptr = ptr->next)

return NULL;

}

size_t idx = h->hfunc(key) % h->size;

HashNode *ptr = malloc(sizeof(HashNode));

ptr->next = h->bucket[idx];

ptr->val = val;

}

size_t i;

for (i = 0; i < h->size; i++)

{

}

}

size_t bkdr_hash(const char *key) {

unsigned int seed = 131;

unsigned int res = 0;

#include <stdio.h>

#include <stdlib.h>

typedef enum ErrCode {

NERV_NORMAL,

/* matrix err */

nerv_error_status(L, &status); \

} while (0)

typedef struct HashNode {

const char *key;

void *val;

size_t size;

} HashMap;

size_t bkdr_hash(const char *key);

cudaDeviceSynchronize(); \

} while (0)

do { \

} while (0)

do { \

{ \

return 0; \

} \

} while (0)

static const char *cublasGetErrorString(cublasStatus_t err) {

return "<unknown>";

}

#define PROFILE_START \

do { \

#define PROFILE_STOP \

float milliseconds = 0; \

} while (0);

#define PROFILE_END

void cudak_(cuda_log_elem)(const Matrix *a, Matrix *b);

void cudak_(cuda_sigmoid)(const Matrix *a, Matrix *b);

void cudak_(cuda_sigmoid_grad)(const Matrix *output, const Matrix *err, Matrix *nerr);

void cudak_(cuda_thres_mask)(const Matrix *a, const Matrix *b, double thres, double low, double high);

void cudak_(cuda_tanh)(const Matrix *a, Matrix *b);

void cudak_(cuda_tanh_grad)(const Matrix *output, const Matrix *err, Matrix *nerr);

#define NERV_GENERIC_CUMATRIX

#include <string.h>

#include <time.h>

size_t i;

fprintf(stderr, "*** [nerv cumatrix profile] **\n");

for (i = 0; i < profile->size; i++)

}

}

}

if (!val)

{

val = malloc(sizeof(float));

*val = 0;

}

*val += delta;

}

}

#define MATRIX_USE_FLOAT

#define nerv_matrix_(NAME) nerv_matrix_cuda_float_##NAME

#define cudak_(NAME) cudak_float_ ## NAME

#define NERV_CUBLAS_(NAME) cublasS##NAME

#include "generic/cumatrix.c"

#undef NERV_CUBLAS_

#undef MATRIX_ELEM_PTR_BASE

#undef MATRIX_ELEM_FMT

#undef MATRIX_ELEM_WRITE_FMT

#define MATRIX_USE_DOUBLE

#define cuda_matrix_(NAME) cuda_matrix_double_##NAME

#define nerv_matrix_(NAME) nerv_matrix_cuda_double_##NAME

#define cudak_(NAME) cudak_double_ ## NAME

#define NERV_CUBLAS_(NAME) cublasD##NAME

#include "generic/cumatrix.c"

#define NERV_CUMATRIX_H

#include "matrix.h"

#include "../common.h"

#endif

cudaStreamSynchronize(0);

}

#ifdef MATRIX_USE_FLOAT

#endif

#ifdef MATRIX_USE_DOUBLE

#endif

}

#ifdef NERV_GENERIC_CUMATRIX

#include "matrix.h"

#include "elem_type.h"

#define NERV_GENERIC_MATRIX

#define NERV_GENERIC_CUKERNEL

#include "../../common.h"

void nerv_matrix_(add)(Matrix *c, const Matrix *a, const Matrix *b,

MATRIX_ELEM alpha, MATRIX_ELEM beta,

Status *status) {

CHECK_SAME_DIMENSION(a, b, status);

CHECK_SAME_DIMENSION(a, c, status);

PROFILE_START

CUBLAS_SAFE_SYNC_CALL(

a->ncol, a->nrow,

&alpha,

MATRIX_ELEM_PTR(a), a->stride / sizeof(MATRIX_ELEM),

void nerv_matrix_(mul)(Matrix *c, const Matrix *a, const Matrix *b,

MATRIX_ELEM alpha, MATRIX_ELEM beta,

#define SWAP(a, b) \

do { int t = (a); (a) = (b); (b) = t; } while (0)

/* Because matrix in Nerv is row-major, here b comes first */

PROFILE_START

CUBLAS_SAFE_SYNC_CALL(

bn, am, bm,

&alpha,

MATRIX_ELEM_PTR(b), b->stride / sizeof(MATRIX_ELEM),

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CHECK_SAME_DIMENSION(a, b, status);

PROFILE_START

cudak_(cuda_sigmoid)(b, a);

}

void nerv_matrix_(sigmoid_grad)(Matrix *nerr, const Matrix *err,

CHECK_SAME_DIMENSION(nerr, err, status);

CHECK_SAME_DIMENSION(nerr, output, status);

PROFILE_START

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

PROFILE_START

PROFILE_STOP

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CHECK_SAME_DIMENSION(a, b, status);

PROFILE_START

cudak_(cuda_thres_mask)(a, b, thres, low, high);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CHECK_SAME_DIMENSION(a, b, status);

PROFILE_START

cudak_(cuda_tanh)(b, a);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CHECK_SAME_DIMENSION(nerr, err, status);

CHECK_SAME_DIMENSION(nerr, output, status);

PROFILE_START

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

Matrix *max, *max_idx;

Matrix *dno;

CHECK_SAME_DIMENSION_RET(a, b, status);

if (status->err_code != NERV_NORMAL)

return NULL;

if (status->err_code != NERV_NORMAL)

{

return NULL;

}

if (status->err_code != NERV_NORMAL)

{ /* FIXME: destroy may also fail? */

return NULL;

}

PROFILE_START

cudak_(cuda_softmax_denominator)(a, max, dno);

cudak_(cuda_softmax_final)(a, max, dno, b);

PROFILE_STOP

NERV_SET_STATUS(status, NERV_NORMAL, 0);

return max_idx;

}

if (status->err_code != NERV_NORMAL)

return NULL;

PROFILE_START

return b;

}

if (status->err_code != NERV_NORMAL)

return NULL;

PROFILE_START

}

Matrix *nerv_matrix_(colsame)(Matrix *a, const Matrix *ref,

if (status->err_code != NERV_NORMAL)

return NULL;

CHECK_SAME_DIMENSION_RET(a, ref, status);

return b;

}

if (status->err_code != NERV_NORMAL)

return NULL;

PROFILE_START

}

void nerv_matrix_(rowmax_idx)(Matrix *a, Matrix **b, Matrix **idx,

if (status->err_code != NERV_NORMAL)

return;

if (status->err_code != NERV_NORMAL)

{

/* FIXME: destroy may also fail? */

return;

}

PROFILE_START

}

void nerv_matrix_(add_row)(Matrix *b, const Matrix *a, double beta,

if (a->ncol != b->ncol)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

if (a->nrow != 1)

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

PROFILE_START

cudak_(cuda_fill)(self, val);

PROFILE_STOP

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

PROFILE_START

PROFILE_STOP

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

void nerv_matrix_(copy_fromd)(Matrix *a, const Matrix *b,

int a_begin, int b_begin, int b_end,

if (!(0 <= b_begin && b_begin < b_end && b_end <= b->nrow &&

a_begin + b_end - b_begin <= a->nrow))

NERV_EXIT_STATUS(status, MAT_INVALID_COPY_INTERVAL, 0);

void nerv_matrix_(copy_fromh)(Matrix *a, const Matrix *b,

int a_begin, int b_begin, int b_end,

if (!(0 <= b_begin && b_begin < b_end && b_end <= b->nrow &&

a_begin + b_end - b_begin <= a->nrow))

NERV_EXIT_STATUS(status, MAT_INVALID_COPY_INTERVAL, 0);

void nerv_matrix_(copy_toh)(Matrix *a, const Matrix *b,

int a_begin, int a_end, int b_begin,

if (!(0 <= a_begin && a_begin < a_end && a_end <= a->nrow &&

b_begin + a_end - a_begin <= b->nrow))

NERV_EXIT_STATUS(status, MAT_INVALID_COPY_INTERVAL, 0);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

MATRIX_ELEM alpha = 1, beta = 0;

if (status->err_code != NERV_NORMAL)

return NULL;

/* FIXME: possible memory leak when lua error is raised */

PROFILE_START

CUBLAS_SAFE_SYNC_CALL_RET(

a->nrow, a->ncol,

&alpha,

MATRIX_ELEM_PTR(a), a->stride / sizeof(MATRIX_ELEM),

}

void nerv_matrix_(mul_elem)(Matrix *c, const Matrix *a, const Matrix *b,

CHECK_SAME_DIMENSION(a, b, status);

CHECK_SAME_DIMENSION(a, c, status);

PROFILE_START

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CHECK_SAME_DIMENSION(a, b, status);

PROFILE_START

cudak_(cuda_log_elem)(a, b);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

Matrix *b;

if (a->ncol != 1)

{

NERV_SET_STATUS(status, MAT_COL_VECTOR_EXP, 0);

return NULL;

}

if (status->err_code != NERV_NORMAL)

return NULL;

PROFILE_START

}

void nerv_matrix_(copy_rows_fromh_by_idx)(Matrix *a, const Matrix *b,

long nrow = a->nrow;

if (!(0 <= b_begin && b_begin + nrow <= idx->ncol))

NERV_EXIT_STATUS(status, MAT_INVALID_COPY_INTERVAL, 0);

}

void nerv_matrix_(copy_rows_fromd_by_idx)(Matrix *a, const Matrix *b,

long nrow = a->nrow;

if (!(0 <= b_begin && b_begin + nrow <= idx->ncol))

NERV_EXIT_STATUS(status, MAT_INVALID_COPY_INTERVAL, 0);

}

void nerv_matrix_(copy_rows_fromd_by_colidx)(Matrix *a, const Matrix *b,

long nrow = a->nrow;

if (!(0 <= b_begin && b_begin + nrow <= idx->nrow))

NERV_EXIT_STATUS(status, MAT_INVALID_COPY_INTERVAL, 0);

#ifdef __NERV_FUTURE_CUDA_7

long nrow = a->nrow;

if (idx->nrow != 1 || idx->ncol != a->nrow)

NERV_EXIT_STATUS(status, MAT_IDX_VECTOR_EXP, 0);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

long nrow = a->nrow;

if (idx->ncol != 1 || idx->nrow != a->nrow)

NERV_EXIT_STATUS(status, MAT_IDX_VECTOR_EXP, 0);

#endif

void nerv_matrix_(expand_frm)(Matrix *a, const Matrix *b,

if (a->nrow != b->nrow)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

NERV_EXIT_STATUS(status, MAT_GENERAL_ERR,

"the width should be 2 * context + 1");

PROFILE_START

PROFILE_STOP

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

void nerv_matrix_(rearrange_frm)(Matrix *a, const Matrix *b,

CHECK_SAME_DIMENSION(a, b, status);

if (b->ncol % step)

NERV_EXIT_STATUS(status, MAT_GENERAL_ERR,

}

void nerv_matrix_(scale_rows_by_col)(Matrix *a, const Matrix *b,

if (a->nrow != b->nrow)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

if (b->ncol != 1)

}

void nerv_matrix_(scale_rows_by_row)(Matrix *a, const Matrix *b,

if (a->ncol != b->ncol)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

if (b->nrow != 1)

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CHECK_SAME_DIMENSION(a, b, status);

PROFILE_START

cudak_(cuda_prefixsum_row)(b, a);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

if (a->nrow != a->ncol)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

PROFILE_START

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CUDA_SAFE_SYNC_CALL(cudaFree(ptr), status);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

static void cuda_matrix_(alloc)(MATRIX_ELEM **dptr,

size_t *stride, long width, long height,

PROFILE_START

CUDA_SAFE_SYNC_CALL(cudaMallocPitch((void **)dptr, stride, width, height),

status);

void nerv_matrix_(add)(Matrix *c, const Matrix *a, const Matrix *b,

MATRIX_ELEM alpha, MATRIX_ELEM beta,

void nerv_matrix_(mul)(Matrix *c, const Matrix *a, const Matrix *b,

MATRIX_ELEM alpha, MATRIX_ELEM beta,

void nerv_matrix_(sigmoid_grad)(Matrix *nerr, const Matrix *err,

void nerv_matrix_(tanh_grad)(Matrix *nerr, const Matrix *err,

Matrix *nerv_matrix_(colsame)(Matrix *a, const Matrix *ref,

void nerv_matrix_(rowmax_idx)(Matrix *a, Matrix **b, Matrix **idx,

void nerv_matrix_(add_row)(Matrix *b, const Matrix *a, double beta,

void nerv_matrix_(copy_fromd)(Matrix *a, const Matrix *b,

int a_begin, int b_begin, int b_end,

void nerv_matrix_(copy_fromh)(Matrix *a, const Matrix *b,

int a_begin, int b_begin, int b_end,

void nerv_matrix_(copy_toh)(Matrix *a, const Matrix *b,

int a_begin, int a_end, int b_begin,

void nerv_matrix_(mul_elem)(Matrix *c, const Matrix *a, const Matrix *b,

void nerv_matrix_(copy_rows_fromh_by_idx)(Matrix *a, const Matrix *b,

void nerv_matrix_(copy_rows_fromd_by_idx)(Matrix *a, const Matrix *b,

void nerv_matrix_(copy_rows_fromd_by_colidx)(Matrix *a, const Matrix *b,

#ifdef __NERV_FUTURE_CUDA_7

#endif

void nerv_matrix_(expand_frm)(Matrix *a, const Matrix *b,

void nerv_matrix_(rearrange_frm)(Matrix *a, const Matrix *b,

void nerv_matrix_(scale_rows_by_col)(Matrix *a, const Matrix *b,

void nerv_matrix_(scale_rows_by_row)(Matrix *a, const Matrix *b,

void nerv_matrix_(thres_mask)(Matrix *a, Matrix *b,

double thres, double low, double high,

#ifdef __NERV_FUTURE_CUDA_7

#endif

#include "matrix.h"

/* FIXME: malloc failure detection */

assert(*self->data_ref > 0);

if (--(*self->data_ref) == 0)

{

/* free matrix data */

free(self->data_ref);

free(self);

}

(*self->data_ref)++;

}

Matrix *self = (Matrix *)malloc(sizeof(Matrix));

self->nrow = nrow;

self->ncol = ncol;

self->dim = 2;

MATRIX_DATA_ALLOC(&MATRIX_ELEM_PTR_BASE(self), &self->stride,

sizeof(MATRIX_ELEM) * self->ncol, self->nrow,

if (status->err_code != NERV_NORMAL)

{

free(self);

return self;

}

}

Matrix *nerv_matrix_(getrow)(Matrix *self, int row) {

#include "../matrix.h"

Matrix *nerv_matrix_(getrow)(Matrix *self, int row);

void nerv_matrix_(data_retain)(Matrix *self);

#ifdef NERV_GENERIC_MMATRIX

#include "matrix.h"

#include "elem_type.h"

#define NERV_GENERIC_MATRIX

#include "../../common.h"

#include "../../io/chunk_file.h"

#include <string.h>

#include <float.h>

if (status->err_code != NERV_NORMAL)

return NULL;

MATRIX_ELEM *arow = MATRIX_ELEM_PTR(a),

return b;

}

if (status->err_code != NERV_NORMAL)

return NULL;

CHECK_SAME_DIMENSION_RET(a, ref, status);

return b;

}

if (status->err_code != NERV_NORMAL)

return NULL;

MATRIX_ELEM *arow = MATRIX_ELEM_PTR(a),

return b;

}

if (status->err_code != NERV_NORMAL)

return NULL;

MATRIX_ELEM *arow = MATRIX_ELEM_PTR(a),

return b;

}

if (status->err_code != NERV_NORMAL)

return;

if (status->err_code != NERV_NORMAL)

{

/* FIXME: destroy may also fail! */

return;

}

MATRIX_ELEM *arow = MATRIX_ELEM_PTR(a),

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

if (status->err_code != NERV_NORMAL)

return NULL;

MATRIX_ELEM *arow = MATRIX_ELEM_PTR(a);

return b;

}

Matrix *b;

if (a->ncol != 1)

{

NERV_SET_STATUS(status, MAT_COL_VECTOR_EXP, 0);

return NULL;

}

if (status->err_code != NERV_NORMAL)

return NULL;

int i;

return b;

}

CHECK_SAME_DIMENSION(a, b, status);

CHECK_SAME_DIMENSION(a, c, status);

int i, j;

void nerv_matrix_(mul)(Matrix *c, const Matrix *a, const Matrix *b,

MATRIX_ELEM alpha, MATRIX_ELEM beta,

#define SWAP(a, b) \

do { int t = (a); (a) = (b); (b) = t; } while (0)

}

void nerv_matrix_(add_row)(Matrix *b, const Matrix *a, double beta,

if (a->ncol != b->ncol)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

if (a->nrow != 1)

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

int i, j;

size_t astride = self->stride;

MATRIX_ELEM *arow = MATRIX_ELEM_PTR(self);

for (i = 0; i < self->nrow; i++)

{

for (j = 0; j < self->ncol; j++)

arow = MATRIX_NEXT_ROW_PTR(arow, astride);

}

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

int i, j;

size_t astride = self->stride;

MATRIX_ELEM *arow = MATRIX_ELEM_PTR(self);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

if (self->nrow != self->ncol)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

int i, j;

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CHECK_SAME_DIMENSION(a, b, status);

int i, j;

size_t astride = a->stride, bstride = b->stride;

}

void nerv_matrix_(sigmoid_grad)(Matrix *nerr, const Matrix *err,

CHECK_SAME_DIMENSION(nerr, err, status);

CHECK_SAME_DIMENSION(nerr, output, status);

int i, j;

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

Matrix *max_idx;

CHECK_SAME_DIMENSION_RET(a, b, status);

if (status->err_code != NERV_NORMAL)

return NULL;

int i, j;

}

void nerv_matrix_(mul_elem)(Matrix *c, const Matrix *a, const Matrix *b,

CHECK_SAME_DIMENSION(a, b, status);

CHECK_SAME_DIMENSION(a, c, status);

int i, j;

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CHECK_SAME_DIMENSION(a, b, status);

int i, j;

size_t astride = a->stride, bstride = b->stride;

}

void nerv_matrix_(expand_frm)(Matrix *a, const Matrix *b,

if (a->nrow != b->nrow)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

NERV_EXIT_STATUS(status, MAT_GENERAL_ERR,

"the width should be 2 * context + 1");

int i, j, k;

for (i = 0; i < a->nrow; i++)

{

MATRIX_ELEM *a_subrow = arow;

if (start < 0) start = 0;

const MATRIX_ELEM *brow = MATRIX_ROW_PTR(b, start);

{

for (k = 0; k < b->ncol; k++)

a_subrow[k] = brow[k];

}

void nerv_matrix_(rearrange_frm)(Matrix *a, const Matrix *b,

CHECK_SAME_DIMENSION(a, b, status);

if (b->ncol % step)

NERV_EXIT_STATUS(status, MAT_GENERAL_ERR,

}

void nerv_matrix_(scale_rows_by_row)(Matrix *a, const Matrix *b,

if (a->ncol != b->ncol)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

if (b->nrow != 1)

}

void nerv_matrix_(scale_rows_by_col)(Matrix *a, const Matrix *b,

if (a->nrow != b->nrow)

NERV_EXIT_STATUS(status, MAT_MISMATCH_DIM, 0);

if (b->ncol != 1)

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

free(ptr);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

static void host_matrix_(alloc)(MATRIX_ELEM **dptr, size_t *stride,

if ((*dptr = (MATRIX_ELEM *)malloc(width * height)) == NULL)

NERV_EXIT_STATUS(status, MAT_INSUF_MEM, 0);

*stride = width;

}

#include "matrix.c"

int i, j;

long nrow, ncol;

FILE *fp = cdp->fp;

NERV_SET_STATUS(status, MAT_INVALID_FORMAT, 0);

return 0;

}

if (status->err_code != NERV_NORMAL)

return NULL;

for (i = 0; i < nrow; i++)

return self;

}

int i, j;

long nrow = self->nrow, ncol = self->ncol;

FILE *fp = cfp->fp;

void nerv_matrix_(copy_fromh)(Matrix *a, const Matrix *b,

int a_begin, int b_begin, int b_end,

if (!(0 <= b_begin && b_begin < b_end && b_end <= b->nrow &&

a_begin + b_end - b_begin <= a->nrow))

NERV_EXIT_STATUS(status, MAT_INVALID_COPY_INTERVAL, 0);

}

void nerv_matrix_(copy_rows_fromh_by_idx)(Matrix *a, const Matrix *b,

if (!(0 <= b_begin && b_begin + a->nrow <= idx->ncol))

NERV_EXIT_STATUS(status, MAT_INVALID_COPY_INTERVAL, 0);

if (idx->nrow != 1)

void nerv_matrix_(add)(Matrix *c, const Matrix *a, const Matrix *b,

MATRIX_ELEM alpha, MATRIX_ELEM beta,

void nerv_matrix_(mul)(Matrix *c, const Matrix *a, const Matrix *b,

MATRIX_ELEM alpha, MATRIX_ELEM beta,

void nerv_matrix_(sigmoid_grad)(Matrix *nerr, const Matrix *err,

Matrix *nerv_matrix_(colsame)(Matrix *a, const Matrix *ref,

void nerv_matrix_(rowmax_idx)(Matrix *a, Matrix **b, Matrix **idx,

void nerv_matrix_(add_row)(Matrix *b, const Matrix *a, double beta,

void nerv_matrix_(copy_fromh)(Matrix *a, const Matrix *b,

int a_begin, int b_begin, int b_end,

void nerv_matrix_(mul_elem)(Matrix *c, const Matrix *a, const Matrix *b,

void nerv_matrix_(copy_rows_fromh_by_idx)(Matrix *a, const Matrix *b,

void nerv_matrix_(expand_frm)(Matrix *a, const Matrix *b,

void nerv_matrix_(rearrange_frm)(Matrix *a, const Matrix *b,

void nerv_matrix_(scale_rows_by_col)(Matrix *a, const Matrix *b,

void nerv_matrix_(scale_rows_by_row)(Matrix *a, const Matrix *b,

#define NERV_GENERIC_MMATRIX

#include <stdlib.h>

#include "../common.h"

#define MATRIX_USE_FLOAT

#define host_matrix_(NAME) host_matrix_float_##NAME

#include "generic/elem_type.h"

#include "generic/mmatrix.c"

int i;

if (status->err_code != NERV_NORMAL)

return NULL;

float *prow = MATRIX_ELEM_PTR_F(self);

#ifndef NERV_MMATRIX_H

#define NERV_MMATRIX_H

#include "matrix.h"

#endif

#include "../lib/matrix/cumatrix.h"

#include "../lib/matrix/cuda_helper.h"

#include <string.h>

Status status;

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

return 0;

}

return 0;

}

{NULL, NULL}

};

extern void nerv_matrix_cuda_float_lua_init(lua_State *L);

extern void nerv_matrix_cuda_double_lua_init(lua_State *L);

void nerv_lua_cumatrix_init(lua_State *L) {

luaL_register(L, NULL, cumatrix_methods);

nerv_matrix_cuda_float_lua_init(L);

nerv_matrix_cuda_double_lua_init(L);

}

#define MATRIX_USE_FLOAT

#define cuda_matrix_(NAME) cuda_matrix_float_##NAME

#define nerv_matrix_(NAME) nerv_matrix_cuda_float_##NAME

#ifdef NERV_GENERIC_CUMATRIX

#include "../../lib/matrix/generic/elem_type.h"

#define MATRIX_DATA_WRITE(L, data, idx, val) cuda_matrix_(write)(L, data, idx, val)

#define MATRIX_DATA_READ(L, data, idx) cuda_matrix_(read)(L, data, idx)

#define NERV_GENERIC_MATRIX

#define NERV_GENERIC_CUKERNEL

#include "../../lib/common.h"

#include "../../lib/matrix/generic/cumatrix.h"

#define BLAS_OP_N CUBLAS_OP_N

static int nerv_matrix_(lua_prefixsum_row)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_thres_mask)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

MATRIX_ELEM thres = luaL_checknumber(L, 3);

MATRIX_ELEM low = luaL_checknumber(L, 4);

MATRIX_ELEM high = luaL_checknumber(L, 5);

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_rand_uniform)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_tanh)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_tanh_grad)(lua_State *L) {

Status status;

Matrix *nerr = luaT_checkudata(L, 1, nerv_matrix_(tname));

Matrix *err = luaT_checkudata(L, 2, nerv_matrix_(tname));

Matrix *output = luaT_checkudata(L, 3, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

extern const char *MATRIX_CUMATRIX_HOST_TNAME;

static int nerv_matrix_(lua_copy_fromh)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, MATRIX_CUMATRIX_HOST_TNAME);

int nargs = lua_gettop(L);

int b_begin = nargs > 2 ? luaL_checkinteger(L, 3) : 0;

int b_end = nargs > 3 ? luaL_checkinteger(L, 4) : b->nrow;

int a_begin = nargs > 4 ? luaL_checkinteger(L, 5) : 0;

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_copy_toh)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, MATRIX_CUMATRIX_HOST_TNAME);

int nargs = lua_gettop(L);

int a_begin = nargs > 2 ? luaL_checkinteger(L, 3) : 0;

int a_end = nargs > 3 ? luaL_checkinteger(L, 4) : a->nrow;

int b_begin = nargs > 4 ? luaL_checkinteger(L, 5) : 0;

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_copy_fromd)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

int nargs = lua_gettop(L);

int b_begin = nargs > 2 ? luaL_checkinteger(L, 3) : 0;

int b_end = nargs > 3 ? luaL_checkinteger(L, 4) : b->nrow;

int a_begin = nargs > 4 ? luaL_checkinteger(L, 5) : 0;

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

extern const char *nerv_matrix_host_float_tname;

static int nerv_matrix_(lua_copy_rows_fromh_by_idx)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, MATRIX_CUMATRIX_HOST_TNAME);

const Matrix *idx = luaT_checkudata(L, 3, nerv_matrix_host_float_tname);

long nrow = a->nrow;

int b_begin = lua_gettop(L) > 3 ? luaL_checkinteger(L, 4) : 0;

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_copy_rows_fromd_by_idx)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

const Matrix *idx = luaT_checkudata(L, 3, nerv_matrix_(tname));

long nrow = a->nrow;

int idx_begin = lua_gettop(L) > 3 ? luaL_checkinteger(L, 4) : 0;

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_copy_rows_fromd_by_colidx)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

const Matrix *idx = luaT_checkudata(L, 3, nerv_matrix_(tname));

long nrow = a->nrow;

int idx_begin = lua_gettop(L) > 3 ? luaL_checkinteger(L, 4) : 0;

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

/* update c's select rows,

* i.e. c[idx[i]] = c[idx[i]] * (1 - beta * alpha) + a[i] * alpha */

Status status;

Matrix *c = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *a = luaT_checkudata(L, 2, nerv_matrix_(tname));

const Matrix *idx = luaT_checkudata(L, 3, nerv_matrix_(tname));

MATRIX_ELEM alpha = luaL_checknumber(L, 4);

MATRIX_ELEM beta = luaL_checknumber(L, 5);

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

/* update c's select rows,

* i.e. c[idx[i]] = c[idx[i]] * (1 - beta * alpha) + a[i] * alpha */

Status status;

Matrix *c = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *a = luaT_checkudata(L, 2, nerv_matrix_(tname));

const Matrix *idx = luaT_checkudata(L, 3, nerv_matrix_(tname));

MATRIX_ELEM alpha = luaL_checknumber(L, 4);

MATRIX_ELEM beta = luaL_checknumber(L, 5);

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

#ifdef NERV_GENERIC_MATRIX

#include "../../lib/matrix/generic/matrix.h"

extern const char *nerv_matrix_(tname);

extern const char *MATRIX_BASE_TNAME;

int nerv_matrix_(lua_new)(lua_State *L) {

Status status;

Matrix *self = nerv_matrix_(create)(luaL_checkinteger(L, 1),

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, self, nerv_matrix_(tname));

return 1;

int nerv_matrix_(lua_destroy)(lua_State *L) {

Status status;

Matrix *self = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 1;

}

static int nerv_matrix_(lua_add)(lua_State *L) {

Status status;

Matrix *c = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *a = luaT_checkudata(L, 2, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 3, nerv_matrix_(tname));

MATRIX_ELEM alpha = luaL_checknumber(L, 4);

MATRIX_ELEM beta = luaL_checknumber(L, 5);

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_mul)(lua_State *L) {

Status status;

Matrix *c = luaT_checkudata(L, 1, nerv_matrix_(tname));

Matrix *a = luaT_checkudata(L, 2, nerv_matrix_(tname));

Matrix *b = luaT_checkudata(L, 3, nerv_matrix_(tname));

: BLAS_OP_N;

int tb = nargs > 6 ? nerv_matrix_(lua_get_blas_op)(*luaL_checkstring(L, 7)) \

: BLAS_OP_N;

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_sigmoid)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_sigmoid_grad)(lua_State *L) {

Status status;

Matrix *nerr = luaT_checkudata(L, 1, nerv_matrix_(tname));

Matrix *err = luaT_checkudata(L, 2, nerv_matrix_(tname));

Matrix *output = luaT_checkudata(L, 3, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_softmax)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 2, nerv_matrix_(tname));

Matrix *b = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, max_idx, nerv_matrix_(tname));

return 1;

static int nerv_matrix_(lua_rowsum)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, b, nerv_matrix_(tname));

return 1;

static int nerv_matrix_(lua_colsum)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, b, nerv_matrix_(tname));

return 1;

static int nerv_matrix_(lua_colsame)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *ref = luaT_checkudata(L, 2, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, b, nerv_matrix_(tname));

return 1;

static int nerv_matrix_(lua_rowmax)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, b, nerv_matrix_(tname));

return 1;

static int nerv_matrix_(lua_rowmax_idx)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

Matrix *b;

Matrix *idx;

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, b, nerv_matrix_(tname));

luaT_pushudata(L, idx, nerv_matrix_(tname));

static int nerv_matrix_(lua_add_row)(lua_State *L) {

Status status;

const Matrix *a = luaT_checkudata(L, 2, nerv_matrix_(tname));

Matrix *b = luaT_checkudata(L, 1, nerv_matrix_(tname));

double beta = luaL_checknumber(L, 3);

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_fill)(lua_State *L) {

Status status;

Matrix *self = luaT_checkudata(L, 1, nerv_matrix_(tname));

double val = luaL_checknumber(L, 2);

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_clip)(lua_State *L) {

Status status;

Matrix *self = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_trans)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, b, nerv_matrix_(tname));

return 1;

static int nerv_matrix_(lua_mul_elem)(lua_State *L) {

Status status;

const Matrix *a = luaT_checkudata(L, 2, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 3, nerv_matrix_(tname));

Matrix *c = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_log_elem)(lua_State *L) {

Status status;

const Matrix *a = luaT_checkudata(L, 2, nerv_matrix_(tname));

Matrix *b = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_decompress)(lua_State *L) {

Status status;

const Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

int orig_col = luaL_checkinteger(L, 2);

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, b, nerv_matrix_(tname));

return 1;

static int nerv_matrix_(lua_expand_frm)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_rearrange_frm)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

int step = luaL_checkinteger(L, 3);

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_scale_rows_by_col)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

static int nerv_matrix_(lua_scale_rows_by_row)(lua_State *L) {

Status status;

Matrix *a = luaT_checkudata(L, 1, nerv_matrix_(tname));

const Matrix *b = luaT_checkudata(L, 2, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

#ifdef NERV_GENERIC_MMATRIX

#include "../../lib/matrix/generic/matrix.h"

#include "../../lib/matrix/generic/elem_type.h"

#define MATRIX_DATA_WRITE(L, data, idx, val) (data[idx] = val)

#define MATRIX_BASE_TNAME nerv_matrix_host_tname

#define NERV_GENERIC_MATRIX

#include "../../lib/common.h"

#include "../../lib/matrix/generic/mmatrix.h"

#include "../../io/chunk_file.h"

#include <string.h>

#define BLAS_OP_N CblasNoTrans

static int nerv_matrix_(lua_get_blas_op)(char ch) {

static int nerv_matrix_(lua_load)(lua_State *L) {

Status status;

ChunkData *cdp = luaT_checkudata(L, 1, nerv_chunk_data_tname);

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, self, nerv_matrix_(tname));

return 1;

static int nerv_matrix_(lua_save)(lua_State *L) {

Status status;

ChunkFile *cfp = luaT_checkudata(L, 2,

nerv_chunk_file_handle_tname);

Matrix *self = luaT_checkudata(L, 1, nerv_matrix_(tname));

NERV_LUA_CHECK_STATUS(L, status);