• torchnet package (1)

    torchnet package (1)

    torchnet

    torchnet

    torchnet是用于torch的代码复用和模块化编程的框架，主要包含四个类

    • Dataset 以不同的方式对数据进行预处理

    • Engine 训练/测试机器学习方法

    • Meter 评估方法性能

    • Log 日志

    Documentation

    torchnet的调用
    local tnt = require 'torchnet'

    tnt.Dataset()

    torchnet提供了多种即插即用的数据容器(data container),例如 concat,split,batch,resample,etc ... 操作。
    tnt.Dataset()实例包含两种主要方法

    • dataset:size() 返回数据集的大小

    • dataset:get(idx) 其中idx是1到size中的数字，返回数据集的第idx个样本

    尽管可以简单的通过for loop循环实现数据集的迭代，为了用户能够以on-the-fly manner找出某些样本或者并行的数据读取，torchnet还提供了一些DatasetIterator类型的迭代器

    在torchnet中，dataset:get()返回的可以是一个Lua table。table中的阈值可以是任意的，即使大多数的数据集都是tensor类型。

    需要注意的是，并不能直接的使用tnt.Dataset()创建该类型，该类型类似于一个抽象类，其下面的具体类包括batchdataset，splitdataset等

    -tnt.ListDataset(self,list,load,[,path])
    参数：self = tnt.ListDataset
    list = tds.Hash
    load = function
    [path = string]
    其中list可以是tds.Hash,table或者torch.LongTensor类型，当访问第i个样本时返回的是load(list[i]),这里load() 是由user提供的闭包函数
    当path参数非空的时候，list对应的应该是string队列，这样传递给load()函数的参数自动加上path前缀，比如访问文件夹'd:/data/mot2015/'下的数据时，不同的子数据集存放在不同的文件里'1.txt','2.txt','3.txt',...这时候 list={'1.txt','2.txt',...},path='d:/data/mot2015/',那么load(x)内的x=path .. x

    1. a={{1,2,3},{2,3,4},{2,2,2}} 
    2. b=torch.Tensor(a) 
    3. f=tnt.ListDataset({list=b:long(),function(x) return x:sum() end}) 
    4. print(f:size()) -- 3 
    5. print(f:get(1)) -- 6 

    注意list只能是hash，table或者longtensor这里容易出现错误的是习惯使用:long()将tensor类型转换，但是对于元素含小数部分的tensor直接类型转换会出现错误！

    • tnt.ListDataset(self,filename,load[,maxload][,path])
      参数： self = tnt.ListDataset
      filename = string 这里filename指定的文件的每一行都是list的一个元素，类似于io.lines(filename)
      load = function 闭包函数
      [maxload = number] 最大加载条目数
      [path = string] 同之前

    • tnt.TableDataset(self,data)
      参数： data = table 针对于小型数据集，data必须Hash索引，对data数据浅层拷贝

    1. a= tnt.TableDataset{data={1,2,3}} 
    2. print(a:get(1)) 

    tnt.TableDataset假定table中key从1连续

    • tnt.TransformDataset(self,dataset,transform[,key])
      参数： self = tnt.TransformDataset
      dataset = tnt.Dataset
      transform = function -- 变换函数
      [key = string] -- 需要变换的key值，如果没有则对dataset中所有数据操作
      当使用tnt.Dataset:get()查询数据集中的数据时，tnt.TransformDataset()以on-the-fly 方式执行闭包函数transform并返回值。
      on-the-fly我的理解是不需要中断过程去执行闭包函数，不涉及从内存中读取数据，而是直接通过cache形式执行，速度很快

    1. a=torch.Tensor{{1,2,3,4},{2,3,4,4}}:long() 
    2. ldata=tnt.ListDataset({list=a,load=function(x) return x end}) 
    3. tdata=tnt.TransformDataset({dataset=ldata,transform=function(x) return x-10 end}) 
    4. print(tdata:get(1)) 

    -- tnt.TransformDataset(self,dataset,transforms)
    注意这个方法是transforms 是一个table，table中的键值对应着dataset[list[i]]的域，如果我们使用tnt.TableDataset{{a=1,b=2,c=3},{a=0,b=3,c=5}}创建Dataset,如下

    1. Tdata = tnt.TableDataset{data={{a=1,b=2,c=3},{a=0,b=3,c=5}}} 
    2. f=tnt.TransformDataset({dataset = Tdata,transforms={a=function(x) return 2*x end,b=function(x) return x-20 end}}) 
    3. f:get(1) -- 这时候输出{a:2 b:-18 c:3},即Tdata[i]的域a执行了transforms.a函数，域b执行transforms.b函数 

    -- tnt.BatchDataset(self,dataset,batchsize[,perm][,merge][,policy][,filter])
    参数：self = tnt.BatchDataset
    dataset = tnt.Dataset
    batchsize = number
    [perm = function]
    [merge = function]
    [policy = string]
    [filter = function]
    功能：将dataset中的batchsize个样本组成一个样本，方便batch处理
    merge函数主要是将batchsize个样本的不同域组合起来，比如数据集的第i个样本写作
    {input = <input_i>,target = <target_i>}
    那么merge()使数据组合为

    1. {<input_i_1>,<ingput_i_2>,... <input_i_n>} 和 {<target_i_1>,<target_i_2>,... <target_i_n>} 
    1. ldata = tnt.ListDataset({ 
    2. list = torch.range(1,40):long(), 
    3. load = function(x) return {input={torch.randn(2,2),torch.randn(3,3)},target =x,target_t = -x } end 
    4. }) 
    5. bdata = tnt.BatchDataset{ 
    6. dataset = ldata, 
    7. batchsize=10 
    8. } 
    9. print(bdata:size()) --输出 4 
    10. print(bdata:get(1)) -- 输出第一个batch，包含3个field:target,input,target_t 
    11. print(bdata:get(1).input[1]) -- 输出一个input元素  

    batch方式操作时，shuffle很重要，所以perm(idx,size)是一个闭包函数，该函数返回shuffle之后idx位置索引的样本，size是dataset的大小。
    dataset的size可能不能被batchsize整除，于是 policy指定了截取方式
    * include-last 不能整除的最后一个batch大小非必要等于batchsize
    * skip-last 最后余出的部分样本舍掉，这并不意味着那些样本就不用了，因为shuffle后的样本排序不定
    * divisible-only 不能整除则报错

    • tnt.CoroutineBatchDataset(self,dataset,batchsize[,perm][,merge][,policy][,filter])
      该方法和BatchDataset方法参数完全一致，实现的功能也几乎一致，唯一不同的地方是该方法可以用于协同程序，用到的时候再看吧。。。

    • tnt.ConcatDataset(self,datasets)
      参数: self＝　tnt.ConcatDataset
      dataset = table
      功能:将table中的数据集concate

    • tnt.ResampleDataset(self,dataset[,sampler][,size])
      给定一个数据集dataset,然后通过sampler(dataset,idx)闭包函数重采样获得新的数据集，size可以指定resample数据集的大小，若没指定则与原来的dataset大小相同,通过源码我们可以看到sampler这个函数其实是用来实现idx的改变

    1. ldata = tnt.ListDataset{list = torch.range(1,40):long(), 
    2. load = function(x) return {input={torch.randn(2,2),torch.randn(3,3)},target =x,target_t = -x } end} 
    3. iidx = tnt.transform.randperm(ldata:size()) 
    4. rdata = tnt.ResampleDataset{dataset = ldata,sampler = function(dataset,idx) return iidx(idx) end} --这其实实现了shuffle功能 
    5. print(rdata:get(1)) 

    • tnt.ShuffleDataset(self,dataset[,size][,replacement])
      实现dataset的shuffle，如果replacement=true，那么指定的size可以大于dataset:size(),大于的部分通过redraw获得
      tnt.ShuffleDataset.resample(self)
      通过该函数在构建ShuffleDataset时就创建fixed的permutation，能够保证多次index同一个值得到的结果相同

    • tnt.SplitDataset(self,dataset,partitions[,initialpartition])
      partitions = table
      [initialpartition = string]
      partitions是一个lua table，table中的元素<key,value>,key是对应partition的名，value是一个0-1的数表示取dataset:size()的比例，或者直接是个number表示对应partitions的大小，initialpartition指定了初始化时加载的partition
      注意 ，该方法在交叉验证时，用起来很爽
      tnt.SplitDataset.select(self,partition) 改变当前选择的partition

    1. sdata = tnt.SplitDataset{data=ldata,partitions={train=0.5,ver=0.25,test=0.25}} 
    2. sdata:select('train') --因为没有指定initialpartition所以需要指定当前的partition才能访问，当指定initialpartition后，该行可以不要，如 sdata = tnt.SplitDataset{data=ldata,partitions={train=0.5,ver=0.25,test=0.25}，initialpartitial='train'} 
    3. print(sdata:get(1)) 
    4. print(sdata:size()) 

    tnt.utils

    torchnet提供了许多工具函数

    • tnt.utils.table.clone(table) 实现table的深度拷贝

    • tnt.utils.table.merge(dst,src) 将src合并到dst中，实现的是浅层拷贝，如果src中的key在dst中已经存在，则覆盖dst中的key值

    1. src={{1,2,3},{4,5,6}} 
    2. dst1={} 
    3. dst2={{1,2,3}} 
    4. dst1=tnt.utils.table.clone(src) 
    5. dst1[1][2]=10 
    6. print(dst1) -- 此时dst1[1][2]=10 
    7. print(src) -- src[1][2]=2 
    8. tnt.utils.table.merge(dst2,src) 
    9. dst2[1][2]=10 
    10. print(dst2) -- dst2[1][2]=10 
    11. print(src) -- src[1][2]=10 
    12. src={a={1,2,3},b={2,3,4}} 
    13. dst1={c={2,2,2}} 
    14. dst2={a={2,3}} 
    15. tnt.utils.table.merge(dst1,src) 
    16. tnt.utils.table.merge(dst2,src) 
    17. print(dst1) -- dst1包含三个元素a,b,c 
    18. print(dst2) -- dst2仅包含2个元素a,b,其中dst2中原来的a被src中的a覆盖 

    • tnt.utils.table.foreach(tbl,closure[,recursive])
      参数： tbl 是一个lua table; closure 闭包函数; [recursive = boolean] 默认值为false
      功能： 对tbl中的每一个元素执行closure函数，如果recursive=true那么tbl将被递归的采用closure函数
      示例：

    1. a={{1,2,3},{2,3,4},{{2,2,2},{1,1,1}}} 
    2. fun = function(v)print('------');print(v)end 
    3. tnt.utils.table.foreach(a,fun) 
    4. tnt.utils.table.foreach(a,fun,true) 

    输出：

    1. ------ 
    2. { 
    3. 1 : 1 
    4. 2 : 2 
    5. 3 : 3 
    6. } 
    7. ------ 
    8. { 
    9. 1 : 2 
    10. 2 : 3 
    11. 3 : 4 
    12. } 
    13. ------ 
    14. { 
    15. 1 : 
    16. { 
    17. 1 : 2 
    18. 2 : 2 
    19. 3 : 2 
    20. } 
    21. 2 : 
    22. { 
    23. 1 : 1 
    24. 2 : 1 
    25. 3 : 1 
    26. } 
    27. } 

    和

    1. ------ 
    2. 1 
    3. ------ 
    4. 2 
    5. ------ 
    6. 3 
    7. ------ 
    8. 2 
    9. ------ 
    10. 3 
    11. ------ 
    12. 4 
    13. ------ 
    14. 2 
    15. ------ 
    16. 2 
    17. ------ 
    18. 2 
    19. ------ 
    20. 1 
    21. ------ 
    22. 1 
    23. ------ 
    24. 1 

    可以发现，recursive = true下递归调用表中元素，直至最里层的单个元素，而在false下，最外层table中每个元素作为输入参数输入到closure函数中

    • tnt.utils.table.canmergetensor(tbl)
      tbl是否能够merge成一个tensor,table中元素是相同规模的tensor则可以mergetensor

    • tnt.utils.table.mergetensor(tbl)
      将tbl中的元素合并成tensor

    1. a={torch.Tensor(3,2),torch.Tensor(3,3)} 
    2. b={torch.Tensor(3):float(),torch.Tensor(3):double()} 
    3. c={torch.Tensor(4),torch.Tensor(4)} 
    4. var={a,b,c} 
    5. for i=1,3 do 
    6. if tnt.utils.table.canmergetensor(var[i]) then 
    7. print(i) 
    8. tnt.utils.table.mergetensor(var[i]) 
    9. end 
    10. end 

    此时显示b,c可以mergetensor，说明只要tensor的规模相同就可以，与其type是否一致无关

    tnt.transform

    该package提供了数据的基本变换，这些变换有的直接作用在数据上，有的作用在数据结构上，使得操作tnt.Dataset非常方便
    这些变换虽然都很简单，但是这些边还可以通过compose或者merge方式实现复杂的变换，compose就是将变换串起来，merge是将变换同时执行，返回每个变换的结果

    • transform.identity(...)
      该变换返回输入本身，这个暂时没想到使用的地方

    • transform.compose(transforms)
      其中参数transforms是一个函数列表，每个函数可以实现一种变换。注意该函数认为transforms中的函数是从1开始连续索引的，如果碰到不连续的了，那么只执行前面连续索引的变换

    1. transform=tnt.transform 
    2. f=transform.compose({ 
    3. function(x) return 2*x end, 
    4. function(x) return x+10 end, 
    5. foo = function(x) return x/2 end 
    6. }) 
    7. a={2,3,4} 
    8. _ =tnt.utils.table.foreach(a,function(x) print(f(x)) end) 输出 14，16，18，即只执行了f中前两个变换 

    注意这里函数列表写成{[1]=function(x) return 2*x end,function(x) return x+10 end,foo = function(x) return x/2 end}则只执行第一个变换，因为key:[2]不存在

    • transform.merge(transforms)
      transforms是一个变换函数列表，对于一个输入，该函数使该输入经过所有变换函数得到的结果merge成table输出

    1. f = transform.merge{ 
    2. [1] = function(x) return torch.Tensor{2*x} end, 
    3. [2] = function(x) return torch.Tensor{x + 10} end, 
    4. [3] = function(x) return torch.Tensor{x / 2} end, 
    5. [4] = function(x) return torch.Tensor{x} end 
    6. } 
    7. f(3) 

    注意这个例子输出的是一个tensor，并不是doc中说的输出一个table，我觉得这个函数除了bug，transform.lua的第144行应该直接return newz就可以了，源代码中使用utils.table.mergetensor(newz)反而会导致合并出错，要想让源代码能执行就必须像上面我给的例子似的，函数返回的是同等规模的tensor，且函数列表中的index必须是从1开始连续索引，源代码要是不改这个函数还是得特别注意

    • transform.tableapply(transform)
      这里的参数transform是一个变换函数，该变换作用于table变量

    1. a={1,2,3,4} 
    2. f=transform.tableapply(function(x) return x*2 end) 
    3. f(a) 

    • transform.tablemergekeys()
      得到的变换方法的输入必须是一个table的table

    1. x={{input=1,target='a'},{input=2,target='b',flag='hard'}} 
    2. transform.tablemergekeys(x) 

    注意这个源码也有问题，源码transform.lua中的243行中ipairs应该修改为pairs，否则给的例子运行不了，因为ipairs从1开始index到第一个非整数key就结束了

    • transform.randperm(size)
      randperm()函数，注意该函数返回的是一个函数句柄，想要获得第i个值，应该用f=transform.randperm(10);f(i)

    • trandform.normalize([threshold])
      输入必须是一个tensor，该函数能够实现标准化，即中心化+归一化，参数threshold是一个number，只有标准差大于threshold时，tensor才会normalize

    1. a=torch.rand(2,3)*10 
    2. print('the std of a is ' .. a:std()) 
    3. f=transform.normalize() 
    4. print('the std of normalized a is ' .. f(a):std() .. ' and the mean is ' .. f(a):sum()) 
  • 相关阅读:
    用互不相同的fib数列的数分解任意整数。
    2015 初赛TG 错题解析
    【模板】判断二叉查找树
    【初赛】完善程序题解题技巧 && 近六年PJ完善程序真题解析
    [NOIP 2012普及组 No.2] 寻宝
    [NOIP 2012普及组 No.1] 质因数分解
    [NOIP 2013普及组 No.4] 车站分级
    [NOIP 2013普及组 No.3] 小朋友的数字
    [NOIP 2013普及组 No.2] 表达式求值
    [NOIP 2013普及组 No.1] 计数问题
  • 原文地址：https://www.cnblogs.com/YiXiaoZhou/p/6771426.html
Copyright © 2020-2023  润新知