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 进阶 - nn package，dp package，nngraph package

1. Lua 简介

• Data Structures 数据结构

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

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

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

• Control flow statements 控制流

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

• Functions 函数

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

  也可以基于 tables 定义 Functions：

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

• Input/Output

  文件 I/O：

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

  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 --recursive
  cd ~/torch
  ./install.sh
  source ~/.bashrc # source ~/.profile for Macs

• Torch 测试

  输入

  th

  可以进入 Torch 解释器，采用 $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 = 10
hiddenLayer1Size = opt.units
hiddenLayer2Size = opt.units

mlp:add(nn.Linear(inputSize, hiddenLayer1Size))
mlp:add(nn.Tanh())
mlp:add(nn.Linear(hiddenLayer1Size, hiddenLayer2Size))
mlp:add(nn.Tanh())

添加输出层.

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

nclasses = 2

mlp: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 values
    end
    
    function 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 dataset
    end
    
    dataset = 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
      end
    end
    
    
    tot = 0
    pos = 0
    for 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 + 1
    end
    print("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 layer
    torch.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.Collapse
    
    vocabularySize = 10000
    embeddingSize = 100 -- a commmon choice for word embeddings
    
    model = 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 = 1
    for 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 + 1
    end
    model: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