torch和lua学习常见问题（重点是nn模块编译和torch编译）

1、点号和冒号在函数调用上的区别

http://blog.csdn.net/wangbin_jxust/article/details/12170233，根据这篇博客的描述，可以发现冒号只是省略了传递的第一个参数self的作用，对于点号需要具体的去传递一个对象的实参，下面做一个实验，用torch

x = torch.Tensor(5):zero()

这个时候输出长度为5的全部为0的Tensor

x = torch.Tensor(5).zero()

[string "x = torch.Tensor(5).zero()"]:1: invalid arguments: no arguments provided
expected arguments: *DoubleTensor*
stack traceback:
[C]: in function 'zero'
[string "x = torch.Tensor(5).zero()"]:1: in main chunk
[C]: in function 'xpcall'
/home/lzhou/torch/install/share/lua/5.1/trepl/init.lua:679: in function 'repl'
...zhou/torch/install/lib/luarocks/rocks/trepl/scm-1/bin/th:204: in main chunk
[C]: at 0x004064f0

这个时候程序报错了，原因是因为点号调用的时候必须要传入实参对象

将代码改为

x = torch.Tensor(5)
x = x.zero(x)

这个时候就可以了！点号调用必须要传入实参

y = torch.Tensor(5)
z = torch.Tensor(5)
z = z.zero(y)

输出的z和y都是0

2、torch中的c接口问题

从官网的介绍来吧，在MSECriterion.lua文件里有

input.THNN.MSECriterion_updateOutput(
input:cdata(),
target:cdata(),
self.output_tensor:cdata(),
self.sizeAverage
)

input.THNN.MSECriterion_updateOutput的语法很奇怪，来看官网的例子了解一下。

官网以“>http://torch.ch/docs/developer-docs.html# 中的threashold.lua为例进行讲解的。



这里的input.nn.threshold_updataOutput函数同样是一个很奇怪的语法，来看看官网的解释。



这句话实际调用的是threshold.c中的这个函数u，但是为什么回去调用这个函数呢？因为在接下来的几行中，会将这个函数注册在input.nn.的table里面，所以就会调用这个函数



这就允许我们为任意的Tensor写任意的函数，不需要很复杂的函数动态的分配了

最后看他们包含在哪些文件里面吧

init.lua



init.c







http://blog.hanschen.site/2016/09/07/lua-and-c.html

但是我们自习观察新版的torch，貌似不是官网给出的这个样子的，为什么呢？官网给出的链接是很久之前的torch的链接，在新版的torch中已经不再使用这种Lua C API的形式来进行lua和c之间的交互了，当然这仅仅对于nn这一个模块，最基础的torch部分其实还是由Lua C API 来实现的。，那么在新版的torch里面我们将以MSECriterion为例进行详细的介绍。

首先在/extra/nn/中存在MSECriterion.lua文件



在整个文件里面再也没有类似之间luaT_pushmetatable这一类的函数了，也就是不存在Lua API C这样的接口了，取而代之的就是很简单的函数，那是什么取代了传统的这种交流方法呢，是LuaJIT的FFI模块，他用来实现和c之间的通信。

其中上面的代码里有

input.THNN.MSECriterion_updateOutput(...)

上面的这句话很模糊，到底是怎么回事，怎么调用的呢？来看一下nn模块的编译过程吧

1）extra/nn目录下面是一系列的lua函数，这是外部接口部分

2）extra/nn/lib/THNN/generic下面是各个函数对应的c的实现

对应的各个目录下面都会有相应的CMakelist.txt文件，用来编译对应目录下的c文件，这样就会生成对应的LibTHNN.so文件，对应的路径在torch/install/lib/lua/5.1.里面

经过了C编译，在底层封装好的函数都放在了动态链接库LibTHNN.so里面，接下来的事情就是lua接口如何去掉用这些C函数。如果用官网的老版教程，肯定是采用Lua C API 的方式来进行，但是这种方法实在是太繁琐了。FFI的出现改变了这一个状态，关于FFI的介绍，详看FFI介绍

FFI能够简化LUA和c之间的通信，那么torch是怎么做的呢？

来到torch/extra/nn文件夹里面，有很多的lua，这些lua是怎么安排的呢？

在这个文件夹下面，首先是init.lua，定义了nn的global这样的table。然后是THNN.lua和THNN_H.lua两个函数，怎么实现的呢？具体看一下THNN.lua

local ffi = require 'ffi'

local THNN = {}

local generic_THNN_h = require 'nn.THNN_h'
-- strip all lines starting wi
4000
th #
-- to remove preprocessor directives originally present
-- in THNN.h
generic_THNN_h = generic_THNN_h:gsub("\n#[^\n]*", "")
generic_THNN_h = generic_THNN_h:gsub("^#[^\n]*\n", "")

通过cpath指定的动态函数库去寻找对应的c模块。

THNN.C = ffi.load(package.searchpath('libTHNN', package.cpath))

首先是加在ffi模块，定义THNN，加在THNN_h,THNN_h里面是一系列C函数在lua中的声明，方便FFI调用。

接下来会有两段话是ffi调用c的话

ffi.cdef(base_declarations)

定义c的两个数据结构

for i=1,#replacements do
local r = replacements[i]
local s = preprocessed
for k,v in pairs(r) do
s = string.gsub(s, k, v)
end
ffi.cdef(s)
end

这样的话所有的c函数定义都用ffi进行了加在，也就是cdef这个函数，他是lua和c之间通信非常关键的一个函数

到目前为止，已经知道lua是怎么和c进行通信的了，但是一开始input.THNN.function()的形式怎么解释呢？看下面的代码

local function_names = extract_function_names(generic_THNN_h)

THNN.kernels = {}
THNN.kernels['torch.FloatTensor'] = THNN.bind(THNN.C, function_names, 'Float', THNN.getState)
THNN.kernels['torch.DoubleTensor'] = THNN.bind(THNN.C, function_names, 'Double', THNN.getState)

torch.getmetatable('torch.FloatTensor').THNN = THNN.kernels['torch.FloatTensor']
torch.getmetatable('torch.DoubleTensor').THNN = THNN.kernels['torch.DoubleTensor']

torch.getmetatable(‘torch.FloatTensor’).THNN = THNN.kernels[‘torch.FloatTensor’]加载FloatTensor的元表，将THNN这一函数加进去，THNN里面存着诸多之前定义的c函数，就这样input这样的tensor就可以轻松点通过THNN来获得相应的函数了。具体细节都在代码里面，这样就可以解释为什么input.THNN.function是合法的了。对于cunn也是类似的实现套路，其他模块也类似。

不过通过上述的代码，发现必须事先装好torch才可以，否则torch.getmetatable是不可行的，torch是在哪里安装的呢？

现在转到/torch/pkg/torch文件夹下面，这个torch文件夹下面主要是实现一些timer，file和Tensor等等类似的基本的操作，来看看是怎么组织的吧。

切入口还是文件夹下面的init.c

#include "general.h"
#include "utils.h"

extern void torch_utils_init(lua_State *L);
extern void torch_random_init(lua_State *L);
extern void torch_File_init(lua_State *L);
extern void torch_DiskFile_init(lua_State *L);
extern void torch_MemoryFile_init(lua_State *L);
extern void torch_PipeFile_init(lua_State *L);
extern void torch_Timer_init(lua_State *L);

extern void torch_ByteStorage_init(lua_State *L);
extern void torch_CharStorage_init(lua_State *L);
extern void torch_ShortStorage_init(lua_State *L)
...
...

一开始首先声明了一系列函数的

LUA_EXTERNC DLL_EXPORT int luaopen_libtorch(lua_State *L);

int luaopen_libtorch(lua_State *L)
{

lua_newtable(L);
lua_pushvalue(L, -1);
lua_setglobal(L, "torch");

torch_utils_init(L);
torch_File_init(L);

torch_ByteStorage_init(L);
torch_CharStorage_init(L);
torch_ShortStorage_init(L);
torch_IntStorage_init(L);
torch_LongStorage_init(L);
torch_FloatStorage_init(L);
torch_DoubleStorage_init(L);
torch_HalfStorage_init(L);

torch_ByteTensor_init(L);
...
...
luaT_newmetatable(L, "torch.Allocator", NULL, NULL, NULL, NULL);
return 1;

首先会设置torch这样的全局table，一次往里面的元表加入方法，这里采用标准的LUA C API的方法，利用虚拟栈的形式，而不是FFI的形式

首先看第一个

torch_utils_init(L);

这个函数到当前目录下的utils.c去寻找，里面最关键的一部分代码是

static int torch_updateerrorhandlers(lua_State *L)
{
THSetErrorHandler(luaTorchErrorHandlerFunction, L);
THSetArgErrorHandler(luaTorchArgErrorHandlerFunction, L);
return 0;
}

static const struct luaL_Reg torch_utils__ [] = {
{"getdefaulttensortype", torch_lua_getdefaulttensortype},
{"isatty", torch_isatty},
{"tic", torch_lua_tic},
{"toc", torch_lua_toc},
{"setnumthreads", torch_setnumthreads},
{"getnumthreads", torch_getnumthreads},
{"getnumcores", torch_getnumcores},
{"factory", luaT_lua_factory},
{"getconstructortable", luaT_lua_getconstructortable},
{"typename", luaT_lua_typename},
{"isequal", luaT_lua_isequal},
{"getenv", luaT_lua_getenv},
{"setenv", luaT_lua_setenv},
{"newmetatable", luaT_lua_newmetatable},
{"setmetatable", luaT_lua_setmetatable},
{"getmetatable", luaT_lua_getmetatable},
{"metatype", luaT_lua_metatype},
{"pushudata", luaT_lua_pushudata},
{"version", luaT_lua_version},
{"pointer", luaT_lua_pointer},
{"setheaptracking", torch_setheaptracking},
{"updateerrorhandlers", torch_updateerrorhandlers},
{NULL, NULL}
};

void torch_utils_init(lua_State *L)
{
torch_updateerrorhandlers(L);
luaT_setfuncs(L, torch_utils__, 0);
}

往torch表里面塞函数，所有上面的函数都可以通过torch.function()进行调用

再来看

extern void torch_Timer_init(lua_State *L);

static const struct luaL_Reg torch_Timer__ [] = {
{"reset", torch_Timer_reset},
{"stop", torch_Timer_stop},
{"resume", torch_Timer_resume},
{"time", torch_Timer_time},
{"__tostring__", torch_Timer___tostring__},
{NULL, NULL}
};

void torch_Timer_init(lua_State *L)
{
luaT_newmetatable(L, "torch.Timer", NULL, torch_Timer_new, torch_Timer_free, NULL);
luaT_setfuncs(L, torch_Timer__, 0);
lua_pop(L, 1);
}

这里首先是往torch.Timer的元表里塞函数，所以这部分调用的时候



和之前略有不同的，两个辅助功能讲完了，其他的辅助功能差不多，但是Tensor部分的压栈等操作要去generic/Tensor.c里面去寻找

static const struct luaL_Reg torch_Tensor_(_) [] = {
{"retain", torch_Tensor_(retain)},
{"free", torch_Tensor_(free)},
{"contiguous", torch_Tensor_(contiguous)},
{"size", torch_Tensor_(size)},
{"elementSize", torch_Tensor_(elementSize)},
{"__len__", torch_Tensor_(size)},
{"stride", torch_Tensor_(stride)},
{"dim", torch_Tensor_(nDimension)},
{"nDimension", torch_Tensor_(nDimension)},
{"set", torch_Tensor_(set)},
{"storage", torch_Tensor_(storage)},
{"storageOffset", torch_Tensor_(storageOffset)},
{"clone", torch_Tensor_(clone)},
{"contiguous", torch_Tensor_(contiguous)},
{"resizeAs", torch_Tensor_(resizeAs)},
{"resize", torch_Tensor_(resize)},
{"narrow", torch_Tensor_(narrow)},
{"sub", torch_Tensor_(sub)},
{"select", torch_Tensor_(select)},
#ifndef TH_REAL_IS_HALF
{"index", torch_Tensor_(indexSelect)},
{"indexCopy", torch_Tensor_(indexCopy)},
{"indexAdd", torch_Tensor_(indexAdd)},
{"indexFill", torch_Tensor_(indexFill)},
{"maskedSelect", torch_Tensor_(maskedSelect)},
{"maskedCopy", torch_Tensor_(maskedCopy)},
{"maskedFill", torch_Tensor_(maskedFill)},
#endif
{"transpose", torch_Tensor_(transpose)},
{"t", torch_Tensor_(t)},
{"unfold", torch_Tensor_(unfold)},
{"isContiguous", torch_Tensor_(isContiguous)},
{"isSameSizeAs", torch_Tensor_(isSameSizeAs)},
{"isSetTo", torch_Tensor_(isSetTo)},
{"isSize", torch_Tensor_(isSize)},
{"nElement", torch_Tensor_(nElement)},
{"copy", torch_Tensor_(copy)},
#ifndef TH_REAL_IS_HALF
{"apply", torch_Tensor_(apply)},
{"map", torch_Tensor_(map)},
{"map2", torch_Tensor_(map2)},
#endif
{"read", torch_Tensor_(read)},
{"write", torch_Tensor_(write)},
{"__index__", torch_Tensor_(__index__)},
{"__newindex__", torch_Tensor_(__newindex__)},
{NULL, NULL}
};

void torch_Tensor_(init)(lua_State *L)
{
luaT_newmetatable(L, torch_Tensor, NULL,
torch_Tensor_(new), torch_Tensor_(free), torch_Tensor_(factory));
luaT_setfuncs(L, torch_Tensor_(_), 0);
lua_pop(L, 1);
#ifndef TH_REAL_IS_HALF
THVector_(vectorDispatchInit)();
#endif
}

上面的代码是不是很熟了，对，这些都是Tensor基本操作，torch7就是通过在文件夹下面编译对应的c和lua获得torch的全局掌控的，接下来就是编译的过程了。

在init.lua里面会首先加在libtorch，获得全局torch这样的概念，接下来就是利用torch来进行各种操作，常见的torch.等等

总结：torch7的torch部分采用LUA C API的形式，而torch有自己的实现，也即LuaT,具体内容看luaT

而对于nn，cunn等附加包采用ffi的形式来进行加载的