Torch - Neural Networks 初步

概述Torch7 Neural Networks 初步 原文：Torch7. Hello World, Neural Networks! Torch7 学习： Lua 学习 - 基本的语法，tabels，scope，functions Torch 学习 - th interpreter，torch package，torch Tensor 数据结构，optim package Torch 进阶 - n @H_502_7@Torch7 Neural Networks 初步

原文：Torch7. Hello World,Neural Networks!

Torch7 学习：

Lua 学习 - 基本的语法，tabels，scope，functions Torch 学习 - th interpreter，torch package，torch Tensor 数据结构，optim package Torch 进阶 - nn package，dp package，nngraph package

1. Lua 简介

Data Structures 数据结构

只有两种数据结构： doubles 和 tables.

tables 可以存储多种类型数据，也可以作为 dict 和 List.

-- doublesvar = 10 -- 默认为全局变量local var2 = 10 -- 局部变量-- tablesdict = {a=1,b=2,c=3} -- dictList = {1,2,3} -- List-- 打印print(dict.a)print(List[1]) -- List 从 1 开始

Control flow statements 控制流

for i=1,10 doif i == 1 then  print("one")elseif i == 2 then  print("two")else  print("something else")endendval = 1while val < 10 doval = val * 2end

Functions 函数

function add_23(n)return n + 23endprint(add_23(7)) -- prints 30

也可以基于 tables 定义 Functions：

tab = {1,3,4}function tab.sum ()c = 0for i=1,#tab do  c = c + tab[i]endreturn cendprint(tab:sum()) -- displays 8 (冒号用于函数调用) 

input/Output

文件 I/O：

file = io.open("test.txt","w")for line in io.lines("~/input.txt") dofile:write(line + "\n") -- write on fileend

I/O on stdin and stdout：

input_val = io.read()io.write("You saID: " .. input_val + "\n") -- alternatively: print ("You saID: " .. input_val) 

2. Torch

Torch 安装

git clone https://github.com/torch/distro.git ~/torch --recursivecd ~/torch./install.shsource ~/.bashrc # source ~/.profile for Macs

Torch 测试

输入

th

可以进入 Torch 解释器，采用 @H_404_271@Ctrl+C 退出.

Lua/Torch 脚本运行

th test_script.lua

Torch package 使用

require 'torch'

torch.Tensor

Torch 使用的是 torch.Tensor 数据结构.

tensor 是 scalars 和 vectors 的泛化.

Torch 的数据都是 torch.Tensor 形式：

a = torch.Tensor(1) -- scalar 标量b = torch.Tensor(2,1) -- vector 向量 (2 rows,1 column)c = torch.Tensor(2,2) -- 2D vector (2 rows,2 columns)-- a,b,c 里存储的数据是无用的值a[1] = 10 -- Now 'a' is a tensor containing an actual value,i.e. 10.d = torch.rand(2,2) -- this is a 2D vector (2x2) with random values.e = d:t() -- 'e' is the transpose of 'd' d 的转置

3. Torch - nn package

nn 是神经网络包. 基于 NN 的网络训练和测试过程如下：

Model - 定义了 Feedforward 网络，conv 网络，recurrent 网络，recursive 网络；网络层数；每层网络的 units 数；每层网络的激活函数；是否使用 dropouts 以避免 overfitting； Training - 包括两部分： 优化算法(如，SGD) 和优化 loss 函数(Torch 里称 Criterion); Data - 网络的数据部分，最重要的 Prediction and Evaluation - 采用训练好的模型进行 prediction，并在 test 数据集测试模型效果.

由于网络参数调整是重要的一部分，这里采用命令行选项：

cmd = torch.Cmdline()cmd:text()cmd:text('Options for my NN')cmd:option('-units',10,'units in the hIDden layer')cmd:option('-learningRate',0.1,'learning rate')-- etc...cmd:text()opt = cmd:parse(arg)

3.1 Model

Model 定义了不同的 containers，决定了数据输入网络，和网络计算输出数据的方式.

例如，将 2D torch Tensor 的每一列输入到网络( Container nn.Parallel )；或者，将相同数据输入到不同的网络层，然后再连接其输出( Container nn.Concat)；或者，最简单的全连接 feed-forward 网络(Container nn.Sequential).

网络定义开始前，需要先设定如下：

require 'nn'mlp = nn.Sequential()

假设，网络有 2 层 hIDden Feedward 网络层. Feedforward 层的计算采用 nn.linear，实现对输入数据的线性变换.

神经网络对于输入数据的 non-linear 表示具有较好的学习能力，因此，网络添加一些 non-linearity 层，如，nn.Tanh，nn.SigmoID，nn.ReLU等. 这里以 tanh 作为变换函数.

假设，10-dim 输入，每一个 hIDden 层 10 个units：

inputSize = 10hIDdenLayer1Size = opt.unitshIDdenLayer2Size = opt.unitsmlp:add(nn.linear(inputSize,hIDdenLayer1Size))mlp:add(nn.Tanh())mlp:add(nn.linear(hIDdenLayer1Size,hIDdenLayer2Size))mlp:add(nn.Tanh())

添加输出层.

假设，二类的分类任务，采用 softmax 变换函数(实际上是，log of softmax):

nclasses = 2mlp:add(nn.linear(hIDdenLayer2Size,nclasses))mlp:add(nn.Logsoftmax())

打印模型，

print mlp

结果如下：

nn.Sequential {  [input -> (1) -> (2) -> (3) -> (4) -> (5) -> (6) -> output]  (1): nn.linear(10 -> 10)  (2): nn.Tanh  (3): nn.linear(10 -> 10)  (4): nn.Tanh  (5): nn.linear(10 -> 2)  (6): nn.Logsoftmax}

其图形化表示：

当定义好 NN 之后，基于 Module:forward 模块可以先测试下，确保网络 forward pass 正常：

out = mlp:forward(torch.randn(1,10))print(out)

其输出是 1×2 tensor，且 out[1][i] 是输入数据属于 class i 的 log 概率值.

3.2 Torch - Trainging

网络训练算法，可以自行设定，即，输入数据处理，送入网络，计算梯度，更新网络参数.

优化算法：

采用 SGD 实现 nn.stochasticGradIEnt ；

需要设定几个参数，如 learning_rate

Loss 函数(Criterion)：

nn package 有很多 loss 函数，这里采用 negative log-likelihood criterion.

训练参数在前面说的命令行里设定.

criterion = nn.ClassNLLCriterion() trainer = nn.stochasticGradIEnt(mlp,criterion)trainer.learningRate = opt.learningRate

3.3 Torch - Data

NN 网络训练开始前，需要数据.

对于数据集的一个要求是，其数据结构应该是 Lua table 的形式，采用 :size() 可以得到 table 内的元素数. table 内的每个元素应该是包含两个子元素的 subtable：

输入( 1×input_size 的 Tensor) ； target class ( 1×1 的 Tensor).

假设数据集保存在 CSV 格式(或其它相似格式)文件中，包括其 target class.

由于 Lua 没有内置读取 CSV 文件的函数，故自定义读取函数如下：

function string:splitAtCommas()  local sep,values = ",",{}  local pattern = string.format("([^%s]+)",sep)  self:gsub(pattern,function(c) values[#values+1] = c end)  return valuesendfunction loadData(datafile)  local dataset = {}  for line in io.lines(datafile) do    local values = line:splitAtCommas()    local y = torch.Tensor(1)    y[1] = values[#values] -- the target class is the last number in the line    values[#values] = nil    local x = torch.Tensor(values) -- the input data is all the other numbers    dataset[i] = {x,y}    i = i + 1  end  function dataset:size() return (i - 1) end -- the requirement mentioned  return datasetenddataset = loadData("trainfile.csv")

数据读取后，采用 nn.stochasticGradIEnt:train() 即可开始网络训练：

trainer:train(dataset)

3.4 Torch - Prediction and Evaluation

网络训练结束后，对于测试数据即可进行分类：

x = torch.randn(10)y = mlp:forward(x)print(y) -- returns the log probability of each class

基于测试数据集，可以计算训练模型的精度，评估其效果：

function argmax(v) -- Lua 中没有该函数，自定义  local maxvalue = torch.max(v)  for i=1,v:size(1) do    if v[i] == maxvalue then      return i    end  endendtot = 0pos = 0for line in io.lines("testfile.csv") do  values = line:splitAtCommas()  local y = torch.Tensor(1)  y[1] = values[#values]  values[#values] = nil  local x = torch.Tensor(values)  local prediction = argmax(mlp:forward(x))  if math.floor(prediction) == math.floor(y[1]) then    pos = pos + 1  end  tot = tot + 1endprint("Accuracy(%) is " .. pos/tot*100)

也可以将结果保存到磁盘，使用时再加载：

print("Weights of saved model: ")print(mlp:get(1).weight) -- mlp:get(1) is the first module of mlp,i.e. nn.linear(10 -> 10)-- mlp:get(1).weight is the weight matrix of that layertorch.save('file.th',mlp)mlp2 = torch.load('file.th')print("Weights of saved model:")print(mlp2:get(1).weight) -- this will print the exact same matrix

4. dp package

dp 是深度学习库，扩展了 nn 很多有用的特点.

dp 库包括了计算机视觉的通用数据集，NLP；并提供了更优雅的数据集创建和加载方式.

dp 库使网络技巧更容易使用，比如 learning rate decaying、Early StopPing on a development set as well as reporting accuracIEs and confusion matrices on training,development and testing sets. 可以参考例子Demo.

4.1 Word embeddings

NLP 领域，word embedding 可以创建 words 的分布表示，以便于分析语法和语义信息.

word2vec 和 GloVe 两种工具能够用于大规模语言建模语料库，生成 word embeddings，直接用于神经网络来表示 words.

例如，假设输入是 words 序列，则可以将每个 word 替换为其预训练的 embedding vector，然后将所有的向量连接，即生成数值化的输入层. 对此，给定输入 words 序列，需要有生成其向量的脚本，可以采用 Python脚本.

另一种方式是，基于 NN 训练 embeddings. 这里，

输入层由 索引序列(sequence of indices) 组成，sequence of indices 拜师每个 word 在 predefined vocabulary 中的 index.

然后，第二层是 embedding 或 lookup table，用于提取对应于 index 的 embedding vector. 其中 lookup table 是一个加权矩阵，其训练类似于其它 NN 层的权重矩阵，第 i 行包含了 vocabulary 中第 i 个 word 的 embedding.

如果随机初始化 lookup table 加权矩阵，开始时的 embeddings 是无用的；当网络开始训练时，BP 将开始更新该加权矩阵，最终能够生成包含语法和语义信息的 embeddings.

Torch：

require 'nn';require 'dp'; --necessary for nn.CollapsevocabularySize = 10000embeddingSize = 100 -- a commmon choice for word embeddingsmodel = nn.Sequential()model:add(nn.Lookuptable(vocabularySize,embeddingSize))model:add(nn.Collapse(2)) -- to concatenate the embeddings of all input words-- then you can add the rest of your network..

预先采用 word2vec 或者 glove 初始化 word embeddings 是一种有效的 embedding 层的初始化方式. 可以明显的减少训练 epoches 的数量.

Torch：

model = nn.Sequential()emb = nn.Lookuptable(vocabularySize,embeddingSize))i = 1for line in io.lines("pretrained.txt") do  vals = line:splitAtCommas()  emb.weight[i] = torch.Tensor(vals) -- set the pretrained values in the matrix  i = i + 1endmodel:add(emb)model:add(nn.Collapse(2))

5. nngraph package

nngraph 扩展了 nn，以便于定义任何类型的 DAG(Directed Acyclic Graph) 神经网络结构. 往往用于有多种类型的输入或输出的网络定义，如 LSTM. nn 提供了相应的模块，但是，以 graph 方式，比以 sequential 方式，更加方便和灵活.

基于 nngraph 重新定义上面的 feed-forward NN 网络：

首先，定义输入(one or more)：

require 'nngraph'inputs = {}table.insert(inputs,nn.IDentity()())input = inputs[1]

然后，构建网络：

lin1 = nn.linear(inputSize,hIDdenLayer1Size)(input)act1 = nn.Tanh()(lin1)lin2 = nn.linear(hIDdenLayer1Size,hIDdenLayer2Size)(act1)act2 = nn.Tanh()(lin2)out = nn.linear(hIDdenLayer2Size,nclasses)(act2)softmax = nn.Logsoftmax()(out)

最后，定义输出(one or more)，并构建 nn.GModule object，该 object 可以用作传统的 nn Container：

outputs = {}table.insert(outputs,softmax)mlp = nn.gModule(inputs,outputs)

6. Related

[1] - Learn Lua in 15 Minutes

[2] - Getting started with Torch

总结

以上是内存溢出为你收集整理的Torch - Neural Networks 初步全部内容，希望文章能够帮你解决Torch - Neural Networks 初步所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。