torch_torchvision - CSDN
torch 订阅
TORCH为多义词:指可导致先天性宫内感染及围产期感染而引起围产儿畸形的病原体,它是一组病原微生物的英文名称缩写,其中T(Toxoplasma)是弓形虫,O(Others)是其他病原微生物,如梅毒螺旋体、带状疱疹病毒、细小病毒B19、柯萨奇病毒等,R(Rubella.Virus)是风疹病毒,C(Cytomegalo.Virus)是巨细胞病毒,H(Herpes.Virus)即是单纯疱疹I/II型。 展开全文
TORCH为多义词:指可导致先天性宫内感染及围产期感染而引起围产儿畸形的病原体,它是一组病原微生物的英文名称缩写,其中T(Toxoplasma)是弓形虫,O(Others)是其他病原微生物,如梅毒螺旋体、带状疱疹病毒、细小病毒B19、柯萨奇病毒等,R(Rubella.Virus)是风疹病毒,C(Cytomegalo.Virus)是巨细胞病毒,H(Herpes.Virus)即是单纯疱疹I/II型。
信息
性    质
病原体
造    成
母婴感染
含    义
一组病原微生物的英文名称缩写
中文名
TORCH
TORCH基本信息
这组微生物感染有着共同的特征,即可造成母婴感染。孕妇由于内分泌改变和免疫力下降易发生原发感染,既往感染的孕妇体内潜在的病毒也容易被激活而发生复发感染。孕妇发生病毒血症时,病毒可通过胎盘或产道传播感染胎儿,引起早产、流产、死胎或畸胎等,以及引起新生儿多个系统、多个器官的损害,造成不同程度的智力障碍等症状。特别在怀孕初的三个月胚胎处于器官形成期,此时受病毒感染,可破坏细胞或抑制细胞的分裂和增殖。器官形成期以后感染病毒,可破坏组织和器官结构,并可形成持续感染,出生后继续排毒,能引起相应的病变。TORCH的感染影响着人口素质,与优生优育有重要关系。
收起全文
精华内容
参与话题
  • Torch安装及使用

    千次阅读 2019-07-26 08:41:45
    安装 依次执行下面四条语句: ...cd ~/torch bash install-deps bash install.sh 说明:第一条的默认安装路径在 home/usr/ 下,根据需要可以修改 问题1: 执行第四条语句容易报错:error: more than ...

    安装 Torch

    • 系统:Ubuntu 12+

    依次执行下面四条语句:

    # in a terminal, run the commands WITHOUT sudo
    git clone https://github.com/torch/distro.git ~/torch --recursive
    
    cd ~/torch
    
    bash install-deps
    
    bash install.sh
    

    说明: 第一条语句的默认安装路径在 home/usr/ 下,根据需要可以修改

    • 第 1 条语句首先安装 LuaJIT 和 Torch 所需的基本包依赖项
    • 第 3 条语句安装 LuaJIT、LuaRocks,然后使用 LuaRocks (Lua包管理器) 安装核心包,如 TORCH、nn 和 PATH,以及一些其他软件包。

    脚本将 Torch 添加到 PATH 变量中。只需 source 一次就可以刷新环境变量。安装脚本将检测到当前的 shell,并在正确的配置文件中修改路径。

    刷新方法:

    # On Linux with bash
    source ~/.bashrc
    # On Linux with zsh
    source ~/.zshrc
    # On OSX or in Linux with none of the above.
    source ~/.profile
    

    删除 Torch

    rm -rf ~/torch
    

    安装包

    使用 luarocks(包管理工具) 安装新的包:

    $ # run luarocks WITHOUT sudo
    $ luarocks install image
    $ luarocks list
    

    进入和退出 Torch

    $ th
    
     ______             __   |  Torch7                                   
     /_  __/__  ________/ /   |  Scientific computing for Lua.         
      / / / _ \/ __/ __/ _ \  |                                           
     /_/  \___/_/  \__/_//_/  |  https://github.com/torch   
                              |  http://torch.ch            
    			  
    th> torch.Tensor{1,2,3}
     1
     2
     3
    [torch.DoubleTensor of dimension 3]
    
    th>
    th> os.exit()
    

    遇到的问题

    error: more than one operator “==” matches these operands

    执行第四条语句容易报错:error: more than one operator “==” matches these operands”,是因为 cuda 和 torch 的头文件都提供了相同的重载运算符,这样编译器在使用的时候就会出现混乱。
    解决方法:禁止使用cuda的头文件编译torch

    export TORCH_NVCC_FLAGS="-D__CUDA_NO_HALF_OPERATORS__"
    

    安装完毕后需要先重启终端,再输入 th,如果没有报错说明安装成功。
    在这里插入图片描述

    luarocks install cutorch 出错

    luarocks install cutorch 出错,要保证 luarocks 调用的是~/torch/install/bin/ 下的 luarocks,且用 sudo 执行。

    sudo /data/monn/torch/install/bin/luarocks install cutorch
    

    Error: No results matching query were found.

    在使用luarocks install时,莫名其妙的提示了

    warning: Failed searching manifest: Failed fetching manifest for …
    Error: No results matching query were found.
    

    解决方法:删除缓存文件,在终端输入:

    sudo rm -rf ~/.cache/luarocks
    

    或者在linux的文件管理器中显示隐藏文件,然后在“/home/当前用户”下找到.cache文件夹,进去后里面有luarocks文件夹,删除该文件夹(或者使用sudo rm -rf),之后重新 luarocks install 即可。

    展开全文
  • Torch学习笔记

    万次阅读 2016-08-15 09:27:05
    Torch笔记 (二)快速入门 Torch中的唯一的数据结构就是Tensor了,而该结构简洁而且强大,非常适合进行矩阵类的数值计算,它是Torch中最最重要的类了。这个Tensor其实就是个多维矩阵,支持矩阵的各种操作。这里需要...

    Torch笔记 (二)快速入门

    Torch中的唯一的数据结构就是Tensor了,而该结构简洁而且强大,非常适合进行矩阵类的数值计算,它是Torch中最最重要的类了。这个Tensor其实就是个多维矩阵,支持矩阵的各种操作。这里需要特别强调的是,lua中的数组(其实是table)下标是从1开始的,因此Tensor对象的下标也是从1开始的。
    咱们从程序猿的角度来说,首先,Tensor也是有类型的,Tensor家族有ByteTensor 、CharTensor 、ShortTensor 、IntTensor 、LongTensor 、FloatTensor 、DoubleTensor 这么几个成员,不用我说,看字面意思就知道这些Tensor各式表示什么意思。默认的是DoubleTensor ,这是为了计算的方便吧。
    然后是Tensor的构造函数了,怎么创建一个Tensor呢,常用的有下面几个。在安装有Torch的机器上输入“th”命令进入Torch环境。

    th> a = torch.Tensor(2,4);print(a)
     0  0  0  0
     0  0  0  0
    [torch.DoubleTensor of size 2x4]
    th> a = torch.Tensor(2,4,2)                                                         
    th> print(b)
    (1,.,.) = 
      6.9414e-310  6.9414e-310
      5.0872e-317  2.3253e+251
      5.0450e+223  1.6304e-322
      6.9414e-310  5.0873e-317
    
    (2,.,.) = 
      1.0277e-321  2.3715e-322
      5.0873e-317  5.9416e-313
      5.0873e-317   8.5010e-96
      6.9677e+252  1.6304e-322
    [torch.DoubleTensor of size 2x4x2]
    
    th> c = torch.IntTensor(2,3);print(c) -- 也可以指定类型
     1.0302e+07  0.0000e+00  1.7000e+09
     1.1000e+02  0.0000e+00  0.0000e+00
    [torch.IntTensor of size 2x3]
    torch.Tensor(sz1 [,sz2 [,sz3 [,sz4]]]])

    上面的的构造函数是创建一个sz1 x sz2 x sx3 x sz4 x …的N维Tensor,例如上述Tensor对象b就是个2 x 4x 2的3维Tensor,但是这样只是定义,没有初始化,需要对其进行赋值操作。

    th> torch.Tensor({{1,2,3,4}, {5,6,7,8}})
     1  2  3  4
     5  6  7  8
    [torch.DoubleTensor of dimension 2x4]

    上面的是用一个lua的table来进行初始化的,即下面的形式

    torch.Tensor(table)

    还可以使用Tensor对象进行初始化

    torch.Tensor(tensor)

    各个Tensor之间的转化

    th> a = torch.IntTensor({3,4,5,3,3});b = torch.DoubleTensor({3.3,4.9,3.2});c = b:typeAs(a);print(c);print(b)    
     3
     4
     3
    [torch.IntTensor of size 3]
    
     3.3000
     4.9000
     3.2000
    [torch.DoubleTensor of size 3]

    Tensor中元素的类型转换,注意其返回的还是一个Tensor对象,而不是单纯的数字

    [Tensor] byte(), char(), short(), int(), long(), float(), double()

    Torch中还有个Storage类,其实就是对应着C语言的一维数组,在一般文件操作使用,节省空间但相关函数不是很丰富,这方面也有ByteStorage, CharStorage, ShortStorage, IntStorage, LongStorage, FloatStorage, DoubleStorage.等待类型,用法和Tensor差不多。由于Storage相当于一个一维数组,所以可以这样创建一个多维数组(这里也是没有初始化)

    th> x =torch.Tensor( torch.LongStorage({2,3,4}));print(x) 
    (1,.,.) = 
      1.1132e+171  6.1707e-114  8.8211e+199  1.0167e-152
      5.7781e-114  7.3587e+223   2.9095e-14   6.9117e-72
      8.8211e+199  1.0167e-152   3.9232e-85   6.9183e-72
    
    (2,.,.) = 
      1.3923e-259  2.2831e-109  1.6779e+243  7.3651e+228
      2.2082e-259  1.1132e+171  6.1707e-114  2.3253e+251
      5.0450e+223  2.8811e+159   1.1995e-22  2.1723e-153
    [torch.DoubleTensor of size 2x3x4]

    因为Tensor对象在操作的时候其实是像在操作C++中的引用,是会改变其本身的值的,所有有些时候我们需要进行备份复制操作,注意在Lua中“:”表示的含义,它表示类的成员。只有包(像nn、torch、optim)等等使用其中的函数时用“.”。

    th> a = torch.randn(3);b = a:clone();print(a,b)
    -0.7112
     0.1953
    -2.0389
    [torch.DoubleTensor of size 3]
    
    -0.7112
     0.1953
    -2.0389
    [torch.DoubleTensor of size 3]

    获取Tensor的维度dim(),还有每个维度具体数值size(),下面显示的Tensor a的第一维为size(1) = 2,第二维为size(2) = 4。获取Tensor元素总个数nElement()

    th> a = torch.Tensor(2,4):zero();print(a);print(a:dim())
     0  0  0  0
     0  0  0  0
    [torch.DoubleTensor of size 2x4]
    
    2
    
    th> print(a:size())                            
     2
     4
    [torch.LongStorage of size 2]
    
    th> print(a:nElement())
    8

    下标访问方式

    x = torch.Tensor(3,3)
    i = 0; x:apply(function() i = i + 1; return i end)
    > x
     1  2  3
     4  5  6
     7  8  9
    [torch.DoubleTensor of dimension 3x3]
    
    > x[2] -- returns row 2
     4
     5
     6
    [torch.DoubleTensor of dimension 3]
    
    > x[2][3] -- returns row 2, column 3
    6
    
    > x[{2,3}] -- another way to return row 2, column 3
    6
    
    > x[torch.LongStorage{2,3}] -- yet another way to return row 2, column 3
    6

    元素复制,只要两个Tensor的元素总数一样就可以,矩阵形状可以不同

    x = torch.Tensor(4):fill(1)
    y = torch.Tensor(2,2):copy(x)
    > x
     1
     1
     1
     1
    [torch.DoubleTensor of dimension 4]
    
    > y
     1  1
     1  1
    [torch.DoubleTensor of dimension 2x2]

    在需要动态扩充Tensor时非常有用的函数resize(sz1 [,sz2 [,sz3 [,sz4]]]])

    th> x = torch.randn(2,4):zero();print(x);print(x:resize(3,4))  
     0  0  0  0
     0  0  0  0
    [torch.DoubleTensor of size 2x4]
    
      0.0000e+00   0.0000e+00   0.0000e+00   0.0000e+00
      0.0000e+00   0.0000e+00   0.0000e+00   0.0000e+00
     8.8211e+199  7.4861e-114   2.9085e-33  1.0251e+170
    [torch.DoubleTensor of size 3x4]

    下面介绍的narrow(dim, index, size),sub(dim1s, dim1e … [, dim4s [, dim4e]]),select(dim, index)返回的对象会得到一个Tensor一部分数据,但是这个返回的对象其实是这部分数据的引用,一旦对该对象进行任何的操作,都将直接影响原来的Tensor
    narrow的dim是待选取的第几个维度,index是开始的位置,结束的位置是index+size-1

    th><font size=3.5> x = torch.Tensor(5, 6):zero();y = x:narrow(1, 2, 3);y:fill(1);print(y);print(x)
     1  1  1  1  1  1
     1  1  1  1  1  1
     1  1  1  1  1  1
    [torch.DoubleTensor of size 3x6]
    
     0  0  0  0  0  0
     1  1  1  1  1  1
     1  1  1  1  1  1
     1  1  1  1  1  1
     0  0  0  0  0  0
    [torch.DoubleTensor of size 5x6]
    
    th> x = torch.Tensor(5, 6):zero();y = x:narrow(2, 2, 3);y:fill(1);print(y);print(x) 
     1  1  1
     1  1  1
     1  1  1
     1  1  1
     1  1  1
    [torch.DoubleTensor of size 5x3]
    
     0  1  1  1  0  0
     0  1  1  1  0  0
     0  1  1  1  0  0
     0  1  1  1  0  0
     0  1  1  1  0  0
    [torch.DoubleTensor of size 5x6]

    sub中的dim1s表示第一个维度开始位置,dim1e表示第一个维度的结束位置,均可以取负值,-1表示最后一个位置,-2表示倒数第二个位置

    th> x = torch.Tensor(5, 6):zero();z = x:sub(2,4,3,4):fill(2);print(z);print(x)
     2  2
     2  2
     2  2
    [torch.DoubleTensor of size 3x2]
    
     0  0  0  0  0  0
     0  0  2  2  0  0
     0  0  2  2  0  0
     0  0  2  2  0  0
     0  0  0  0  0  0
    [torch.DoubleTensor of size 5x6]

    select(dim, index)返回的Tensor比原来的Tensor少一维,dim依然表示第几个维度

    th> x = torch.Tensor(5,6):zero();y = x:select(1, 2):fill(2);print(y);print(x)
     2
     2
     2
     2
     2
     2
    [torch.DoubleTensor of size 6]
    
     0  0  0  0  0  0
     2  2  2  2  2  2
     0  0  0  0  0  0
     0  0  0  0  0  0
     0  0  0  0  0  0
    [torch.DoubleTensor of size 5x6]
    
    th> x = torch.Tensor(2,3,4):zero();y = x:select(1, 2):fill(2);print(y);print(x)   
     2  2  2  2
     2  2  2  2
     2  2  2  2
    [torch.DoubleTensor of size 3x4]
    
    (1,.,.) = 
      0  0  0  0
      0  0  0  0
      0  0  0  0
    
    (2,.,.) = 
      2  2  2  2
      2  2  2  2
      2  2  2  2
    [torch.DoubleTensor of size 2x3x4]

    还有下标操作符[{ dim1,dim2,… }] or [{ {dim1s,dim1e}, {dim2s,dim2e} }]也是返回一个Tensor,这种方式更加简洁和常用

    th> x = torch.Tensor(3, 4):zero();x[{ 1,3 }] = 1;print(x) -- 和x[1][3] = 1 等价
     0  0  1  0
     0  0  0  0
     0  0  0  0
    [torch.DoubleTensor of size 3x4]
    
    th><font size=3.5> x = torch.Tensor(3, 4):zero();x[{ 2,{2,4} }] = 1;print(x) -- 2表示第一维index = 2,{2,4}表示第二维index从2到4            
     0  0  0  0
     0  1  1  1
     0  0  0  0
    [torch.DoubleTensor of size 3x4]
    
    th><font size=3.5> x = torch.Tensor(3, 4):zero();x[{ {},2 }] = torch.range(1,3);print(x)  -- {}表示第一个维度的所有index,2表示第二个维度index = 2 range生成的Tensor叫IDTensor
     0  1  0  0
     0  2  0  0
     0  3  0  0
    [torch.DoubleTensor of size 3x4]
    
    th> x = torch.Tensor(3, 4):fill(5);x[{ {},2 }] = torch.range(1,3);x[torch.lt(x,3)] = -2;print(x) ; 
     5 -2  5  5
     5 -2  5  5
     5  3  5  5
    [torch.DoubleTensor of size 3x4]

    index(dim, index)函数就不一样了,返回的Tensor就是一个新的Tensor了,和原来的Tensor就没有关系了,这里的index比较特殊,必须是LongTensor类型的

    th> x = torch.randn(3,5);print(x);y = x:index(2,torch.range(2,4):typeAs(torch.LongTensor()));y:mul(100);print(y);print(x)
     0.6146 -0.3204 -1.2182  1.5573 -0.7232
    -1.1692 -0.0071  3.1590  0.6008  0.4566
     0.1957 -0.4057  2.0835 -0.3365 -1.3541
    [torch.DoubleTensor of size 3x5]
    
     -32.0396 -121.8182  155.7330
      -0.7097  315.9025   60.0773
     -40.5727  208.3459  -33.6517
    [torch.DoubleTensor of size 3x3]
    
     0.6146 -0.3204 -1.2182  1.5573 -0.7232
    -1.1692 -0.0071  3.1590  0.6008  0.4566
     0.1957 -0.4057  2.0835 -0.3365 -1.3541
    [torch.DoubleTensor of size 3x5]
    
    th>x = torch.randn(3,5);print(x);y = x:index(2,torch.LongTensor({1,4}));y:mul(100)print(y);print(x) -- 指定获取第二维中index = 1 和index = 4 即原Tensor中第1列和第4列形成的新Tensor
    -0.4880 -1.6397 -0.3257 -0.5051 -0.1214
    -0.4002  1.3845  0.4411  0.1753  2.0174
     0.5882  0.9351 -0.7685  0.6377 -1.7308
    [torch.DoubleTensor of size 3x5]
    
    -48.8024 -50.5097
    -40.0198  17.5341
     58.8207  63.7730
    [torch.DoubleTensor of size 3x2]
    
    -0.4880 -1.6397 -0.3257 -0.5051 -0.1214
    -0.4002  1.3845  0.4411  0.1753  2.0174
     0.5882  0.9351 -0.7685  0.6377 -1.7308
    [torch.DoubleTensor of size 3x5]

    indexCopy(dim, index, tensor)将tensor复制进来,index也是LongTensor类型的,类似的函数还有indexAdd(dim, index, tensor),indexFill(dim, index, val)

    th> x = torch.randn(3,5);print(x);y = torch.Tensor(2,5);y:select(1,1):fill(-1);y:select(1,2):fill(-2);print(y);x:indexCopy(1,torch.LongTensor{3,1},y);print(x)
     0.8086  1.7714 -1.6337  0.2549  0.2131
     1.4018 -0.9938  0.3035  1.6247 -0.1368
     0.3516 -1.3728 -0.5203  0.2754 -1.6965
    [torch.DoubleTensor of size 3x5]
    
    -1 -1 -1 -1 -1
    -2 -2 -2 -2 -2
    [torch.DoubleTensor of size 2x5]
    
    -2.0000 -2.0000 -2.0000 -2.0000 -2.0000
     1.4018 -0.9938  0.3035  1.6247 -0.1368
    -1.0000 -1.0000 -1.0000 -1.0000 -1.0000
    [torch.DoubleTensor of size 3x5]

    这里需要强调一下,二维Tensor的第二个维度为1时这个Tensor还是二维的

    -- 这个是一维的Tensor
    th> a = torch.Tensor({1,2,3,4,5});print("dim=" .. a:dim());print(a);print(a:size()) 
    dim=1
     1
     2
     3
     4
     5
    [torch.DoubleTensor of size 5]
     5
    [torch.LongStorage of size 1]
    [torch.LongStorage of size 1]
    -- 这个就是二维的Tensor了,此时是5x1的二维Tensor了
    th> x = torch.Tensor({1,2,3,4,5});y = x:reshape(a:size(1),1);print(y);print(y:dim())
     1
     2
     3
     4
     5
    [torch.DoubleTensor of size 5x1]
    2
    -- 也可以这么写
    th> y = torch.Tensor({{1},{2},{3},{4},{5}});print(y);print(y:dim()) 
     1
     2
     3
     4
     5
    [torch.DoubleTensor of size 5x1]
    -- 这样就变成了1x5的二维Tensor了
    th> y = torch.Tensor({{1,2,3,4,5}});print(y);print(y:dim())                              
     1  2  3  4  5
    [torch.DoubleTensor of size 1x5]
    2
    -- 或者这样也可以,都是二维的Tensor了,size()的值即各维度的大小,因为是二维,所以有两个值
    th> x = torch.Tensor({1,2,3,4,5});y = x:reshape(1,a:size(1));print(y:dim());print(y);;print(y:size())
    2
     1  2  3  4  5
    [torch.DoubleTensor of size 1x5]
     1
     5
    [torch.LongStorage of size 2]

    gather(dim, index)取出指定区域的数据,其中index的维数必须和最后输出的Tensor形状(维数,输出Tensor形状是mxn,index必须也是mxn)相同,且数据类型是LongTensor

    -- dim = 1
    result[i][j][k]... = src[index[i][j][k]...][j][k]...
    -- dim = 2
    result[i][j][k]... = src[i][index[i][j][k]...][k]...
    -- etc.
    -- src 是原来的Tensor
    -- 如果想取对角线上的所有元素,输出是一个nx1的具有两个维度(Tensor:dim() = 2),则index必须是nx1具有两个维度的LongTensor
    
    th> x = torch.rand(5, 5);print(x);y = x:gather(1, torch.LongTensor{{1, 2, 3, 4, 5}, {2, 3, 4, 5, 1}});print(y)
     0.2188  0.3625  0.7812  0.2781  0.9327
     0.5342  0.3879  0.7225  0.6031  0.7325
     0.1464  0.4534  0.5134  0.9993  0.6617
     0.0594  0.6398  0.1741  0.7357  0.6613
     0.2926  0.7286  0.7255  0.7108  0.1820
    [torch.DoubleTensor of size 5x5]
    
     0.2188  0.3879  0.5134  0.7357  0.1820
     0.5342  0.4534  0.1741  0.7108  0.9327
    [torch.DoubleTensor of size 2x5]
    -- 如果要取出对角线上的元素(1,1),(2,2),(3,3),(4,4),(5,5)这个1x5(二维Tensor)的Tensor出来 index = torch.LongTensor({{1, 2, 3, 4, 5}});  y = x:gather(1, index) 其中的index是1x5的二维Tensor
    -- 如果要取出对角线(1,2),(2,3),(3,4),(4,5),(5,1)的1x5Tensor,index = torch.LongTensor({{5,1, 2, 3, 4}});  y = x:gather(1, index)或者index = torch.LongTensor({{2, 3, 4, 5,1}});  y = x:gather(2, index)
    -- 看个例子
    th> x = torch.rand(5, 5);print(x);y = x:gather(2, torch.LongTensor({ {1,2},{2,3},{3,4},{4,5},{5,1} }) );print(y)    
     0.8563  0.2664  0.6895  0.8124  0.0788
     0.0503  0.6646  0.7659  0.4013  0.0670
     0.4760  0.0517  0.9621  0.7437  0.1162
     0.4069  0.9932  0.6118  0.6200  0.3585
     0.9795  0.9601  0.9098  0.4714  0.5577
    [torch.DoubleTensor of size 5x5]
    
     0.8563  0.2664
     0.6646  0.7659
     0.9621  0.7437
     0.6200  0.3585
     0.5577  0.9795
    [torch.DoubleTensor of size 5x2]

    scatter(dim, index, src|val)就是把其它Tensor src或者标量值val写入到自己参数含义和gather一样

    x = torch.rand(2, 5)
    > x
     0.3227  0.4294  0.8476  0.9414  0.1159
     0.7338  0.5185  0.2947  0.0578  0.1273
    [torch.DoubleTensor of size 2x5]
    
    y = torch.zeros(3, 5):scatter(1, torch.LongTensor{{1, 2, 3, 1, 1}, {3, 1, 1, 2, 3}}, x)
    > y
     0.3227  0.5185  0.2947  0.9414  0.1159
     0.0000  0.4294  0.0000  0.0578  0.0000
     0.7338  0.0000  0.8476  0.0000  0.1273
    [torch.DoubleTensor of size 3x5]
    
    z = torch.zeros(2, 4):scatter(2, torch.LongTensor{{3}, {4}}, 1.23)
    > z
     0.0000  0.0000  1.2300  0.0000
     0.0000  0.0000  0.0000  1.2300
    [torch.DoubleTensor of size 2x4]

    nonzero(tensor)返回一个nx2 LongTensor,包含原Tensor中所有的非零值的下标和值

    th> x = torch.rand(4, 4):mul(3):floor():int();y = torch.nonzero(x);print(x);print(y) 
     2  1  0  2
     2  1  2  1
     1  0  1  0
     2  0  2  2
    [torch.IntTensor of size 4x4]
    
     1  1
     1  2
     1  4
     2  1
     2  2
     2  3
     2  4
     3  1
     3  3
     4  1
     4  3
     4  4
    [torch.LongTensor of size 12x2]

    转置操作transpose(dim1, dim2)或者直接t(),仅对二维Tensor有用
    对多维tensor转置permute(dim1, dim2, …, dimn)

    x = torch.Tensor(3,4,2,5)
    > x:size()
     3
     4
     2
     5
    [torch.LongStorage of size 4]
    
    y = x:permute(2,3,1,4) -- 等价于 y = x:transpose(1,3):transpose(1,2)
    > y:size()
     4
     2
     3
     5
    [torch.LongStorage of size 4]

    还有对tensor对象每个元素应用函数处理apply(function)

     = 0
    z = torch.Tensor(3,3)
    z:apply(function(x)
      i = i + 1
      return i
    end)
    > z
     1  2  3
     4  5  6
     7  8  9
    [torch.DoubleTensor of dimension 3x3]

    针对两个tensor的每个元素处理map(tensor, function(xs, xt))

    x = torch.Tensor(3,3)
    y = torch.Tensor(9)
    i = 0
    x:apply(function() i = i + 1; return i end) -- fill-up x
    i = 0
    y:apply(function() i = i + 1; return i end) -- fill-up y
    > x
     1  2  3
     4  5  6
     7  8  9
    [torch.DoubleTensor of dimension 3x3]
    > y
     1
     2
     3
     4
     5
     6
     7
     8
     9
    [torch.DoubleTensor of dimension 9]
    th> z =x:map(y, function(xx, yy) return xx*xx + yy end);print(z)
      2   6  12
     20  30  42
     56  72  90
    [torch.DoubleTensor of size 3x3]

    将tensor进行切分split([result,] tensor, size, [dim]),size是切分的单位(大小),dim是指定的维度,即在那个维度上面切分

    th> x = torch.randn(3,10,15) 
    th> x:split(2,1)             
    {
      1 : DoubleTensor - size: 2x10x15
      2 : DoubleTensor - size: 1x10x15
    }
                                                                          [0.0003s]
    th> x:split(4,2)             
    {
      1 : DoubleTensor - size: 3x4x15
      2 : DoubleTensor - size: 3x4x15
      3 : DoubleTensor - size: 3x2x15
    }
                                                                          [0.0004s]
    th> x:split(5,3)    
    {
      1 : DoubleTensor - size: 3x10x5
      2 : DoubleTensor - size: 3x10x5
      3 : DoubleTensor - size: 3x10x5
    }

    然后是一些tensor的Math操作函数,例如sum、add、sub、mul、div、mode、max、min、std、mean、pow、rand、randn、log、range、exp、abs、floor、sqrt等还有很多很多Math官网
    这些函数因为非常常用已经放到了torch包中,既可以mean = torch.mean(x),也可以mean = x:mean()

    th> x = torch.range(1,15,3);print(x);print(x:mean());print(torch.mean(x))
      1
      4
      7
     10
     13
    [torch.DoubleTensor of size 5]
    
    7
    7

    还有一个很常用的是torch.sort([resval, resind,] x [,dim] [,flag]),默认升序,返回两个tensor,第一个是排好序的tensor,第二个是排好序的tensor每个元素对应的下标的tensor

    th> x = torch.Tensor({8.3,3.4,5.7,1.7,9.3});y,index = x:sort(true);print(y,index) 
    -- 也可以这样写 y,index = torch.sort(x,true);print(y,index) 
     9.3000
     8.3000
     5.7000
     3.4000
     1.7000
    [torch.DoubleTensor of size 5]
    
     5
     1
     3
     2
     4
    [torch.LongTensor of size 5]

    下一篇Torch实现线性回归

    展开全文
  • python torch学习(一)

    万次阅读 2018-07-15 19:32:36
    1.torch与numpy的比较及二者之间的转换。import torch import numpy as np numpy_data = np.arange(15).reshape(3,5) print 'numpy_data',numpy_data torch_data = torch.from_numpy(numpy_data) print 'torch_data...

    1.torch与numpy的比较及二者之间的转换。

    import torch
    import numpy as np
    
    numpy_data = np.arange(15).reshape(3,5)
    print 'numpy_data',numpy_data
    torch_data = torch.from_numpy(numpy_data)
    print 'torch_data',torch_data
    numpy_data1 = torch_data.numpy()
    print 'numpy_data1',numpy_data1

    2.构建torch矩阵

    #coding=utf-8
    import torch
    
    data = torch.Tensor(3,5)   #构建一个3×5未初始化的矩阵
    print data
    
    data1 = torch.rand(5,3)    #构建一个随机初始化的矩阵
    print data1
    print data1.size()

    3.torch加法运算

    #coding=utf-8
    import torch
    
    x = torch.rand(5,3)    #构建一个随机初始化的矩阵
    y = torch.rand(5,3)
    
    print x + y
    
    print torch.add(x,y)
    
    #提供一个输出作为参数
    result = torch.Tensor(5,3)
    torch.add(x,y,out=result)
    print result
    
    #就地操作
    y.add_(x)
    print y
    
    
    注意:任何改变张量的操作方法都是以后缀_结尾的

    4.切片以及view方法

    #coding=utf-8
    import torch
    
    x = torch.rand(4,4)    #构建一个随机初始化的矩阵
    print x[:,1]  #索引操作
    y = x.view(16)
    print y
    z = x.view(-1,8)   #2*8
    print z
    

    5.创建tensor

    #coding=utf-8
    import torch
    import numpy as np
    
    x = torch.rand(4,4)    #构建一个随机初始化的矩阵
    print torch.is_tensor(x)   #返回True
    print torch.numel(x)     #返回16
    #创造操作
    #1.对角元素为1
    y = torch.eye(3,4)   #对角元素为1,其余为0
    print y
    
    #2.从numpy.ndarray类创造一个tensor类
    a = np.array([1,2,3])
    t = torch.from_numpy(a)
    print t
    t[0] = -1
    print a   #[-1  2  3],注意这种创造方式tensor 和ndarray共享相同的内存
    
    #3.利用torch.linspace
    b = torch.linspace(2,10,steps=10)  #注意step是start 和end 之间的样本数
    print b
    
    #4.torch.logspace() 返回10^start和10^end之间的对数间隔
    c = torch.logspace(0.1,1.0,steps=5)
    print c
    
    #5.填充1
    d = torch.ones(4,4)
    print d
    
    #6.torch.arange()
    e = torch.arange(1,4)  #默认step = 1
    print e
    
    #7.torch.zeros()
    f = torch.zeros(6)
    print f
    g = torch.zeros(2,3)
    print g
    
    

    6.索引、切片、连接、换位

    #coding=utf-8
    import torch
    
    #cat在给定维度上,对输入的张量序列进行连接操作
    x = torch.randn(2,3)
    
    y = torch.cat((x,x),0) #竖着摞在一起
    print y
    
    z = torch.cat((x,x),1)  #横着落在一起
    print z
    
    #chunk在给定维度上将张量进行分块处理。chunks:要返回的分块的个数
    g = torch.chunk(x,2,1)
    print g
    
    print '--'*20
    #split 将输入张量分割成相同size的chunks。如果不能整分,则最后一块小于其他块
    w = torch.split(z,3,dim=1)  #3:代表每个分块大小为3
    print w
    
    #stack沿着一个新的维度对输入张量进行连接
    f = torch.stack((x,x),dim=0)
    print f
    
    #转置
    e = torch.t(x)
    print e
    
    

    展开全文
  • Torch是一个基于BSD License的开源的机器学习的框架,早在2002年就发布了Torch的初版。Torch一直聚焦于大规模的机器学习应用,尤其是图像或者视频应用等领域,在超过5万次的下载,在学校和企业中也有着不小的影响力...

    这里写图片描述
    Torch是一个基于BSD License的开源的机器学习的框架,早在2002年就发布了Torch的初版。Torch一直聚焦于大规模的机器学习应用,尤其是图像或者视频应用等领域,在超过5万次的下载,在学校和企业中也有着不小的影响力,而Torch7希望能够做到像Matlab那样,为机器学习提供环境。

    基本信息

    项目 说明
    官方网站 http://torch.ch/
    开源/闭源 开源
    License类别 BSD License
    代码管理地址 https://github.com/torch/torch7
    开发语言 C,Lua
    支持平台 由于使用C和Lua,Torch可以支持多种操作系统诸如Linux/MacOSX/iOS/Android等
    当前版本 7.0 (2017/02/27)

    功能特色

    Torch的目标在保证使用的方式非常简单的基础上最大化地保证算法的灵活性和速度。Torch的核心是流行的神经网络和简单易用的优化库,使用Torch能在实现复杂的神经网络拓扑结构的时候保持最大的灵活性,同时可以使用并行的方式对CPU和GPU进行更有效率的操作。在LuaJIT/C/CUDA等基础之上,Torch的主要特性如下:

    • 强大的N维数组操作的支持
    • 提供很多对于索引/切片等的常用操作
    • 常见线性代数计算的支持
    • 神经网络和基于能量的模型
    • 支持GPU计算
    • 可嵌入,可移植到iOS或者Android

    Torch与Lua

    Lua在Torch中扮演了一个重要角色,Torch认为LuaJIT是那个“合适的脚本语言”,LuaJIT的优势如下

    • 快速,并且拥有一个透明的JIT编译器
    • 像Python一样简单而且可读
    • 和C语言的接口非常干净和简单
    • 可嵌入到任何环境中,比如iphone的引用,视频游戏或者web后端等

    Lua vs Python

    为什么不使用Python而使用LuaJIT,Torch给出的理由是:

    • 纠结于速度和效率,而超级轻量级的LuaJIT则不会在这方面碍手碍脚
    • 希望整个Torch框架是自包含的
    • 希望能更容易地将代码移植到任何平台,比如移植到iphone上而不需要修改已经写好的脚本
    • 希望有更容易的扩展性,LuaJIT的FFI接口是最容易学习的方式之一。

    整体来说,这些点LuaJIT都更好地适应Torch,所以选择了LuaJIT

    关于如何快速上手Lua,可以参看如下文章,快速Catchup

    LUA快速使用指南 https://blog.csdn.net/liumiaocn/article/details/80342596

    安装部署

    下载install-all脚本

    [root@devops ~]# wget  https://raw.githubusercontent.com/torch/ezinstall/master/install-all
    ...省略
    Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.0.133|:443... connected.
    HTTP request sent, awaiting response... 200 OK
    Length: 2096 (2.0K) [text/plain]
    Saving to: ‘install-all’
    ...省略
    [root@devops ~]#

    使用脚本进行安装

    无需其他,只需保证网络能够连接正常,等待结束即可完成安装

    [root@devops ~]# sh install-all 
    INFO: Preparing to install dependencies...
    ...省略
    Total download size: 104 M
    ...省略
      Verifying  : libstdc++-4.8.5-16.el7.x86_64                                                                                    122/122 
    Installed:
    ...省略
      Verifying  : libdv-1.0.0-17.el7.x86_64                                                                                          49/49 
    
    Installed:
      python-ipython.noarch 0:3.2.1-1.el7                                                                                                   
    ...省略
    Cloning into 'OpenBLAS'...
    ...省略
    make -j 2 -C test all
    ...省略
    TEST 22/22 potrf:bug_695 [OK]
    RESULTS: 22 tests (22 ok, 0 failed, 0 skipped) ran in 0 ms
    ...省略
     OpenBLAS build complete. (BLAS CBLAS LAPACK LAPACKE)
      OS               ... Linux             
      Architecture     ... x86_64               
      BINARY           ... 64bit                 
      C compiler       ... GCC  (command line : cc)
      Fortran compiler ... GFORTRAN  (command line : gfortran)
      Library Name     ... libopenblas_haswellp-r0.3.0.dev.a (Multi threaded; Max num-threads is 2)
    ...省略
    ==> Torch7's dependencies have been installed
    INFO: Dependencies installed successfully.
    INFO: Preparing to install torch...
    Installing Torch into: /usr/local
    Cloning into 'luajit-rocks'...
    ...省略
    Already on 'master'
    Already up-to-date.
    -- The C compiler identification is GNU 4.8.5
    -- The CXX compiler identification is GNU 4.8.5
    -- Check for working C compiler: /usr/bin/cc
    -- Check for working C compiler: /usr/bin/cc -- works
    -- Detecting C compiler ABI info
    -- Detecting C compiler ABI info - done
    -- Check for working CXX compiler: /usr/bin/c++
    -- Check for working CXX compiler: /usr/bin/c++ -- works
    ...省略
    Install the project...
    -- Install configuration: "Release"
    -- Installing: /usr/local/include/luaconf.h
    -- Installing: /usr/local/include/lua.h
    -- Installing: /usr/local/include/lauxlib.h
    -- Installing: /usr/local/include/lualib.h
    -- Installing: /usr/local/include/lua.hpp
    -- Installing: /usr/local/include/luajit.h
    -- Installing: /usr/local/lib/libluajit.so
    -- Installing: /usr/local/bin/luajit
    ...省略
    -- Installing: /usr/local/etc/luarocks/config.lua
    -- Installing: /usr/local/bin/luarocks
    -- Installing: /usr/local/bin/luarocks-admin
    ...省略
    Cloning into 'sundown-ffi'...
    ...省略
    Cloning into 'cwrap'...
    r...省略
    Cloning into 'paths'...
    ...省略
    Install the project...
    -- Install configuration: "Release"
    -- Installing: /usr/local/lib/luarocks/rocks/paths/scm-1/lua/paths/init.lua
    ...省略
    Cloning into 'torch7'...
    ...省略
    [100%] Built target torch
    cd build && make install
    [ 55%] Built target TH
    [ 58%] Built target luaT
    [100%] Built target torch
    Install the project...
    -- Install configuration: "Release"
    -- Installing: /usr/local/share/cmake/torch/TorchExports.cmake
    ...省略
    -- Installing: /usr/local/lib/libTH.so.0
    -- Installing: /usr/local/lib/libTH.so
    ...省略
    -- Installing: /usr/local/include/TH/THTensor.h
    -- Installing: /usr/local/include/TH/THTensorApply.h
    -- Installing: /usr/local/include/TH/THTensorDimApply.h
    -- Installing: /usr/local/include/TH/THTensorMacros.h
    -- Installing: /usr/local/include/TH/THVector.h
    ...省略
    Cloning into 'luaffifb'...
    ...省略
    Cloning into 'nn'...
    ...省略
    [100%] Building C object lib/THNN/CMakeFiles/THNN.dir/init.c.o
    Linking C shared module libTHNN.so
    [100%] Built target THNN
    cd build && make install
    [100%] Built target THNN
    Install the project...
    -- Install configuration: "Release"
    ...省略
    -- Installing: /usr/local/lib/luarocks/rocks/nn/scm-1/lib/libTHNN.so
    -- Set runtime path of "/usr/local/lib/luarocks/rocks/nn/scm-1/lib/libTHNN.so" to "$ORIGIN/../lib:/usr/local/lib:/opt/OpenBLAS/lib"
    -- Installing: /usr/local/include/THNN/THNN.h
    -- Installing: /usr/local/include/THNN/generic/THNN.h
    ...省略
    Cloning into 'dok'...
    ...省略
    Cloning into 'gnuplot'...
    ...省略
    Cloning into 'qtlua'...
    ...省略
    Cloning into 'qttorch'...
    ...省略
    Cloning into 'sys'...
    ...省略
    Cloning into 'image'...
    ...省略
    Cloning into 'optim'...
    ...省略
    Cloning into 'trepl'...
    ...省略
    => Torch7 has been installed successfully
    
      + Extra packages have been installed as well:
         $ luarocks list
    
      + To install more packages, do:
         $ luarocks search --all
         $ luarocks install PKG_NAME
    ...省略
      + packages installed:
        - sundown   :  ok
        - cwrap     :  ok
        - paths     :  ok
        - torch     :  ok
        - nn        :  ok
        - dok       :  ok
        - gnuplot   :  ok
        - qtlua     :  ok
        - qttorch   :  ok
        - lfs       :  ok
        - penlight  :  ok
        - sys       :  ok
        - xlua      :  ok
        - image     :  ok
        - optim     :  ok
        - cjson     :  ok
        - trepl     :  ok
    
    INFO: Torch installed successfully.
    [root@devops ~]#

    删除脚本

    https://raw.github.com/torch/ezinstall/master/clean-old.sh

    安装确认

    确认luagit

    Torch7希望自己是自包含的,这里面luagit起到了一个重要作用,luajit会同时一同被安装,所以需要进行确认

    [root@devops ~]# which luajit
    /usr/local/bin/luajit
    [root@devops ~]# luajit -v
    LuaJIT 2.0.4 -- Copyright (C) 2005-2017 Mike Pall. http://luajit.org/
    
     _____              _     
    |_   _|            | |    
      | | ___  _ __ ___| |__  
      | |/ _ \| '__/ __| '_ \ 
      | | (_) | | | (__| | | |
      \_/\___/|_|  \___|_| |_|
    
    [root@devops ~]# 

    使用此版本的luajit进行动作确认

    [root@devops ~]# luajit
    LuaJIT 2.0.4 -- Copyright (C) 2005-2017 Mike Pall. http://luajit.org/
    
     _____              _     
    |_   _|            | |    
      | | ___  _ __ ___| |__  
      | |/ _ \| '__/ __| '_ \ 
      | | (_) | | | (__| | | |
      \_/\___/|_|  \___|_| |_|
    
    JIT: ON CMOV SSE2 SSE3 SSE4.1 fold cse dce fwd dse narrow loop abc sink fuse
    > print "Hello World"
    Hello World
    > 

    可以看到Torch7下的luajit确实很小

    [root@devops ~]# du -k /usr/local/bin/luajit
    648 /usr/local/bin/luajit
    [root@devops ~]#

    确认luarocks

    除此之外,luarocks作为Lua的包管理的工具也非常重要,确认其版本以及是否能够进行正常操作,后续会通过luarocks install来安装所需的依赖

    [root@devops ~]# luarocks
    LuaRocks 2.3.0, a module deployment system for Lua
    ...省略
    CONFIGURATION
        Lua version: 5.1
        Configuration files:
            System: /usr/local/etc/luarocks/config.lua (ok)
            User  : /root/.luarocks/config-5.1.lua (not found)
    ...省略
    [root@devops ~]# luarocks list  nn
    ...省略
    nn
       scm-1 (installed) - /usr/local/lib/luarocks/rocks
    [root@devops ~]# 

    确认th

    Torch可以通过交互式的th进行操作,确认其是否能够正常进入

    [root@devops ~]# th
    
      ______             __   |  Torch7 
     /_  __/__  ________/ /   |  Scientific computing for Lua. 
      / / / _ \/ __/ __/ _ \  |  Type ? for help 
     /_/  \___/_/  \__/_//_/  |  https://github.com/torch 
                              |  http://torch.ch 
    
    th>

    总结

    这篇文章介绍了Torch的概要信息,以及如何在centos7上安装最新版本的torch7.

    展开全文
  • 神经网络学习小记录48——windows下的torch=1.2.0环境配置学习前言环境内容Anaconda安装下载Cudnn和CUDA配置torch环境安装VSCODE 学习前言 好多人问环境怎么配置,还是出个教程吧。 环境内容 torch:1.2.0 ...
  • torch.load的坑

    万次阅读 2019-08-15 01:33:50
    使用torch.load的时候遇见两个坑 第一个是遇到如下错误: ModuleNotFoundError: No module named 'models' 官方说明如下:the serialized data is bound to the specific classes and the exact directory ...
  • torch库的使用

    千次阅读 2020-10-18 09:48:04
    torch库的使用(pytorch框架): 在pytorch中,FloatTensor是基本的数据格式,等同于ndarray在numpy中的地位。 另一种常用格式是变量Variable,常用于计算图。 FloatTensor.view:与Matlab的reshape类似,对矩阵...
  • 理解torch.zeros()

    万次阅读 2019-01-14 19:29:20
    输入: import torch x=torch.zeros(3) print(x) 结果: tensor([0., 0., 0.])
  • torch.size ()

    万次阅读 2019-08-28 14:55:49
    torch.size ():查看当前Tensor的维度,用法也很简单: 终端进入Python环境 >>>import torch >>>a = torch.Tensor([[1, 2, 3], [4, 5, 6]]) >>>a.size() (2, 3) ...
  • Torch

    千次阅读 2018-11-29 16:50:44
    Torch torch包含了多维张量的数据结构以及基于其上的多种数学运算。此外,它也提供了多种实用工具,其中一些可以更有效地对张量和任意类型进行序列化的工具。 它具有CUDA的对应实现,可以在NVIDIA GPU上进行张量...
  • Torch常用函数详解T

    千次阅读 2019-11-08 13:10:16
    torch 本笔记引用自PyTorch中文文档 包torch包含了多维疑是的数据结构及基于其上的多种数学操作。 1. 张量Tensors torch.is_tensor(obj): 如果obj是一个pytorch张量,则返回True torch.is_storage(obj): ...
  • 如何安装torch、Pytorch、torchversion

    千次阅读 2020-03-19 14:58:21
    一、安装torch Pytorch官方网站 根据自己的python版本和电脑配置选择安装版本 方案一 直接在cmd上下载,即输入 pip install torch===1.4.0 torchvision===0.5.0 -f ...
  • torch.where用法

    万次阅读 2018-09-22 20:20:42
    把矩阵x中大于5的变成5了 import torch x = torch.linspace(1, 27, steps=27).view(9, 3) bbb = torch.where(x &gt; 5, torch.full_like(x, 5), x) print(bbb)
  • torch.Tensor和torch.tensor的区别

    万次阅读 多人点赞 2019-06-10 16:34:48
    在Pytorch中,Tensor和tensor都用于... a = torch.Tensor([1, 2]) >>> a tensor([1., 2.]) >>> a=torch.tensor([1,2]) >>> a tensor([1, 2]) 首先我们从根源上来看看torch.Tensor()和to...
  • pytorch:torch.mm()和torch.matmul()

    万次阅读 2018-09-11 15:51:36
    torch.mm(mat1, mat2, out=None) → Tensor torch.matmul(mat1, mat2, out=None) → Tensor 对矩阵mat1和mat2进行相乘。 如果mat1 是一个n×m张量,mat2 是一个 m×p 张量,将会输出一个 n×p 张量out。 参数 ...
  • 在运行torch中出现这个错误。 错误内容大概就是指输入类型是CPU(torch.FloatTensor),而参数类型是GPU(torch.cuda.FloatTensor)。 关于数据类型的链接:官方链接 首先,请先检查是否正确使用了CUDA。 通常我们...
  • train_label_batch = torch.from_numpy(train_label_batch) 解决办法:将数据类型转换成FloatTensor即可,如下,加一行代码Tensor.type(torch.FloatTensor) train_label_batch = torch.from_numpy(train_label_...
  • torch.mul() 和 torch.mm() 的区别

    万次阅读 多人点赞 2019-01-04 09:24:11
    torch.mul(a, b)是矩阵a和b对应位相乘,a和b的维度必须相等,比如a的维度是(1, 2),b的维度是(1, 2),返回的仍是(1, 2)的矩阵 torch.mm(a, b)是矩阵a和b矩阵相乘,比如a的维度是(1, 2),b的维度是(2, 3),返回的就是...
  • torch.randn和torch.rand有什么区别

    万次阅读 多人点赞 2019-05-04 17:28:28
    torch.rand和torch.randn有什么区别? y = torch.rand(5,3) y=torch.randn(5,3) 一个均匀分布,一个是标准正态分布。 均匀分布 torch.rand(*sizes, out=None)→ Tensor 返回一个张量,包含了从区间[0, 1)的均匀...
  • torch.device作用

    万次阅读 2019-07-18 17:35:58
    torch.device代表将torch.Tensor分配到的设备的对象。torch.device包含一个设备类型(‘cpu’或‘cuda’)和可选的设备序号。如果设备序号不存在,则为当前设备。如:torch.Tensor用设备构建‘cuda’的结果等同于...
1 2 3 4 5 ... 20
收藏数 58,839
精华内容 23,535
关键字:

torch