[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

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 \

nn/init.lua nn/layer_repo.lua nn/param_repo.lua nn/layer_dag.lua nn/network.lua \

io/sgd_buffer.lua \

tnn/init.lua tnn/sutil.lua tnn/tnn.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

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))

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.

function nerv.warning(fmt, ...)

nerv.printf(

string.format("(%s)[nerv] warning: %s\n",

end

--- Create a class (Torch-compatible).

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')

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)

self.rate = layer_conf.dropout_rate or global_conf.dropout_rate

if self.rate == nil then

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")

end

function DropoutLayer:get_params()

end

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

function DuplicateLayer:__init(id, global_conf, layer_conf)

self:check_dim_len(1, -1)

if #self.dim_out < 1 then

nerv.error('no output specified')

end

function DuplicateLayer: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

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

function GraphLayer:__init(id, global_conf, layer_conf)

self:graph_init(layer_conf.layer_repo, layer_conf.connections)

end

table.insert(param_repos, ref.layer:get_params())

end

end

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 IdentityLayer = nerv.class('nerv.IdentityLayer', 'nerv.Layer')

function IdentityLayer:__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

function IdentityLayer:get_params()

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

nerv.error('primitive layer does not have sublayers')

end

end

end

end

end

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

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

end

-- input1:x

-- input2:h

-- input3:c

-- 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(3, 2) -- x, h, c and h, c

end

function LSTMLayer:init(batch_size, chunk_size)

self.dag:init(batch_size, chunk_size)

end

-- NOTE: this is a full matrix gate

function LSTMGateLayer:__init(id, global_conf, layer_conf)

for i = 1, #self.dim_in do

nerv.LinearTransParam,

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

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 RNNLayer = nerv.class('nerv.RNNLayer', 'nerv.GraphLayer')

function RNNLayer:__init(id, global_conf, layer_conf)

self:check_dim_len(1, 1)

local din = layer_conf.dim_in[1]

local pr = layer_conf.pr

if pr == nil then

end

local layers = {

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

function SigmoidLayer:__init(id, global_conf, layer_conf)

self:check_dim_len(1, 1)

end

function SigmoidLayer:init()

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

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

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

*val += delta;

}

CUBLAS_SAFE_SYNC_CALL(cublasCreate(&(context->cublas_handle)), status);

CURAND_SAFE_SYNC_CALL(curandCreateGenerator(&(context->curand_gen),

CURAND_RNG_PSEUDO_DEFAULT), status);

CUDA_SAFE_SYNC_CALL(cudaEventCreate(&(context->profile_start)), status);

CUDA_SAFE_SYNC_CALL(cudaEventCreate(&(context->profile_stop)), status);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

static void free_cuda_handles(CuContext *context, Status *status) {

CUBLAS_SAFE_SYNC_CALL(cublasDestroy(context->cublas_handle), status);

CURAND_SAFE_SYNC_CALL(curandDestroyGenerator(context->curand_gen), status);

CUDA_SAFE_SYNC_CALL(cudaEventDestroy(context->profile_start), status);

NERV_SET_STATUS(status, NERV_NORMAL, 0);

}

CuContext *context = (CuContext *)malloc(sizeof(CuContext));

if (status->err_code != NERV_NORMAL)

return NULL;

context->profile = nerv_hashmap_create(PROFILE_HASHMAP_SIZE, bkdr_hash, strcmp);

void nerv_cuda_context_select_gpu(CuContext *context,

int dev, Status *status) {

if (status->err_code != NERV_NORMAL)

return;

if (status->err_code != NERV_NORMAL)

return;

NERV_SET_STATUS(status, NERV_NORMAL, 0);

#include "cuda_helper.h"

typedef struct CuContext {

cublasHandle_t cublas_handle;

cudaEvent_t profile_start, profile_stop;

curandGenerator_t curand_gen;

void nerv_cuda_context_clear_profile(CuContext *context);

void nerv_cuda_context_accu_profile(CuContext *context, const char *name, float delta);

void nerv_cuda_context_select_gpu(CuContext *context, int dev, Status *status);

void nerv_cuda_context_destroy(CuContext *contex, Status *status);

#endif

context, status)

#define NERV_GENERIC_MATRIX

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

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

#include <string.h>

#include <math.h>

#include <float.h>

Matrix *nerv_matrix_(colsum)(Matrix *a, MContext *context, Status *status) {

int nerv_cuda_context_lua_select_gpu(lua_State *L) {

Status status;

nerv_cuda_context_select_gpu(luaT_checkudata(L, 1, nerv_cuda_context_tname),

NERV_LUA_CHECK_STATUS(L, status);

return 0;

}

int nerv_cuda_context_lua_new(lua_State *L) {

Status status;

NERV_LUA_CHECK_STATUS(L, status);

luaT_pushudata(L, self, nerv_cuda_context_tname);

return 1;

#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) {

return c

end

--- CUDA float matrices

-- @type nerv.CuMatrixFloat

-- @type nerv.MMatrix

--- A wrapper function for `copy_fromh`

b:copy_fromh(self, ...)

end

#! /usr/bin/env luajit

require 'nerv'

-- only for backward compatibilty, will be removed in the future

local function _add_profile_method(cls)

cls.print_profile = function () c:print_profile() end

cls.clear_profile = function () c:clear_profile() end

end

end

local script = arg[1]

local script_arg = {}

for i = 2, #arg do

end

arg = script_arg

dofile(script)

license = "BSD"

}

dependencies = {

}

build = {

type = "make",

end

end

self.layers = layers

self.inputs = inputs

self.outputs = outputs

self.parsed_conn = parsed_conn

self.queue = queue

end

function DAGLayer:init(batch_size, chunk_size)

for id, ref in pairs(self.queue) do

table.insert(param_repos, ref.layer:get_params())

end

end

DAGLayer.PORT_TYPES = {

if layer_type == nil then

nerv.error('layer type `%s` not found', ltype)

end

nerv.error("layer config table is need")

end

end

end

end

end

end

function LayerRepo:get_layer(lid)

local layer = self.layers[lid]

if layer == nil then

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

self.params = {}

if plist ~= nil then

for i, p in ipairs(plist) do

self.params[p.id] = p

end

end

if self.params[pid] ~= nil then

nerv.error("duplicate params with the same id: %s", pid)

end

self.params[pid] = p

end

table.remove(self.params, pid)

end

for i, repo in ipairs(repos) do

if not nerv.is_type(repo, "nerv.ParamRepo") then

nerv.error("nerv.ParamRepo objects expected, got %s", repo)

end

return p

end