Torch7系列教程之Torch深度学习库教程(一)

写在前面的话

torch深度学习库中包含有很多实用性很强的数学计算库，包括有nn、nngraph、optim优化库、rnn神经网络库等等。我们首先从torch7中最基础的数据运算的torch库进行学习。

torch库

简介：Torch程序库中包含多维张量的数据结构，并定义了这些数据的数学运算。 此外，它提供了许多实用函数，可用于有效地序列化张量和任意类型，以及其他有用的实用函数。
Torch库中包含有以下的包

• Tensor库
  • Tensor数据类型
  • 数学运算库
  • 存储接口库，为Tensor对象提供了基本的存储
• 文件File I/O接口库
  • File文件操作库：常见文件处理库
  • Disk File文件操作库：磁盘文件处理库
  • Memory File文件操作库：RAM中存储操作
  • Pipe File文件操作库 ：管道文件操作
  • 高级文件操作库：定义更高级的序列化功能
• 一些实用工具
  • Timer库：关于时间操作库函数
  • Tester库：通用测试器框架
  • CmdLine库：命令行参数解析库
  • Random库：随机数生成以及使用库
  • 实用Torch类程序操作库函数

1 Tensor库

张量类(Tensor)是Torch中最重要的类， 几乎每个包都依赖于此类。 它是处理数字数据的类。 与Torch7中的几乎所有表一样，Tensor可序列化。Tensor在Torch中是一个十分重要的概念，类似于Python中numpy数组。
Torch中基本数据类型有以下几种:

浮点数类型	整数类型
torch.DoubleTensor(64位浮点数)	torch.LongTensor(64位有符号整型)
torch.FloatTensor(32位浮点数，默认)	torch.IntTensor(32位有符号整型)
torch.HalfTensor(16位浮点数)	torch.ShortTensor(16位有符号整型)
-	torch.CharTensor(有符号8位整型)
-	torch.ByteTensor(无符号8位整型)

1.1 Tensor数据使用简介

数据类型简介
Tensor是多位矩阵，维度的数量是无限的，最多可以使用LongStorage创建的维度来确定矩阵的大小，例如

-- creation of a 4D-tensor 4x5x6x2
z = torch.Tensor(4,5,6,2)
-- for more dimensions
s = torch.LongStorage(6)
s[1] = 4;s[2] = 3;s[3] = 7;s[4] = 6;s[5] = 2
x = torch.Tensor(s)

Tensor的维数可以通过nDimension()或dim()查询。第i个维度的大小由size(i)返回。 可以调用size()函数来返回包含所有尺寸大小的LongStorage。

x.nDimension()
x.dim()

Tensor的内部数据表示
Tensor的实际数据包含在Storage中，他可以通过storage()函数来进行访问。虽然Tensor的存储包含在一个独立的Storage中，但是它可能是在存储器中是不连续的：Storage中使用的第一个位置是由storageOffset()所给出来的(它从1开始)。第i个维度中从一个元素到另一个元素所需要的步长由stride(i)给出来。例如下面的操作可以说明这一点：

x = torch.Tensor(7,7,7)		--create a Tensor
a = x[3][4][5]		-- accessing the elemnet
-- also equivalently by the following step
a = x:storage()[x:storageOffset()+(3-1)*x:stride(1)+(4-1)*x:stride(2)+(5-1)*x:stride(3)]

可以说Tensor是查看Storage的一种特殊方式：Storage仅代表一块内存，而Tensor将这块内存解释为具有尺寸。
注意：大多数数字运算仅针对FloatTensor和DoubleTensor实现。

默认创建Tenor的矩阵可以由以下函数来确定：

torch.setdefaulttensortype(arg)		--设置默认tensor类型
torch.getdefaulttensortype(arg)		--获取默认tensor类型
-- 其中arg可以是”torch.FloatTensor“等等字符串

接下来介绍在Tenso库中r常用的一些操作函数

1.2 Tensor构造函数

用于创建新的Tensor对象，分配新的内存。 默认情况下，新分配的内存元素未初始化，因此可能包含任意数字。 以下是构建新Tensor的几种方法。

• torch.Tensor() :创建一个空的张量
• torch.Tensor(tensor) :返回一个新张量，该张量引用与给定张量相同的Storage。 size，stride和storage offset与给定张量相同。新的Tensor现在将“查看”与给定张量相同的存储。 得到的结果是，对张量元素的任何修改都会对给定张量的元素产生影响，并没有存储副本。
  举个例子：

x = torch.Tensor(2,5):fill(3.14)		--fill the tensor with 3.14
y = torch.Tensor(x)
y = y:zero()		-- fill the tensor with zero
-- now x and y has the same value

• torch.Tensor(sz1[,sz2[,sz3[,sz4]]]]) :创建一个sz1 x sz2 x sz3 x sz4的张量。
• torch.Tensor(sizes, [strides]) ：创建任意维度数字的张量。 LongStorage大小给出了张量每个维度的大小。 可选的LongStorage strides为每个维度中从一个元素到下一个元素的跳转提供了必要。 当然，大小和步幅必须具有相同数量的元素。 如果未给出，或者如果stride的某些元素为负，则将计算stride()函数，以使张量在内存中尽可能连续。
  举个例子：

size = torch.LongStorage({4,5,6})
x = torch.Tensor(size)		--create size of 4x5x6 tensor

• torch.Tensor(storage,[storage,sizes,[strides]]) :返回从位置storageOffset（> = 1）开始使用现有Storage存储的张量。 张量的每个维度的大小由LongStorage的大小给出。每个维度中从一个元素到下一个元素所需的跳转由可选参数LongStorage strides给出。 如果未给出，或者如果stride的某些元素为负，则将计算stride()，以使张量在内存中尽可能连续。对存储元素的任何修改都会对新Tensor的元素产生影响，并不存在内存副本。
• torch.Tensor(storage, [storageOffset, sz1 [, st1 … [, sz4 [, st4]]]]) :
  更方便的构造函数（对于先前的构造函数）假定数量小于或等于4的维度。szi是第i个维度的大小，sti是第i个维度的跨度。
• torch.Tensor(table) :假定该参数是一个Lua数字数组。 构造函数返回表大小的新Tensor，其中包含所有表元素。 该表可能是多维的。

1.3 作用于Torch上的一些操作函数

下面介绍一些可以用于操作张量的一些函数，很多函数已经所定义它们可以通过面向对象的“方法调用”样式(src:function(…))或者功能性的样式(torch.function(…))进行调用它们。其中src是张量，下面介绍多个不一样的函数功能。

向量的克隆

• [Tensor] tensor:clone() :返回一个张量的克隆(内存副本)
• [Tensor] tensor:fiil(number) :将这个张量中的元素用number来进行填充
• [Tensor] tensor:contiguous() :如果给定的Tensor内容在内存中是连续的，则返回完全相同的Tensor（无内存副本）。否则（在内存中不连续），返回一个克隆（内存副本）。
• [Tensor or string] tensor:type(typename) :如果typename参数是空的，则返回一个所给出张量类型的类型名；如果typename不是空的并且与tensor描述一样张量的字符串，则将此张量转化为和typename一样的张量(没有内存副本)；如果typename不是空的并且与tensor描述的不一样，则返回typename相同的张量(有内存副本，但是可能会有精度的缺失)
• [Tensor] tensor1:typeAs(tensor2) :与type(tensor:type())作用一样。
• [Tensor] tensor:byte(),char(),short(),int(),long(),float(),double() :将Tensor转化为与之对应的另一种Tensor。

查询大小的一些函数

• [numebr] tensor:nDimension() :返回Tensor的维度
• [number] tensor:dim() :返回Tensor的维度
• [number] tensor:size(dim) :返回对应维度的元素个数
• [LongStorage] tensor:size() ：返回Tensor的大小或者是#tensor
• [number] tensor:stride(dim) :返回在指定尺寸dim中从一个元素到下一个元素所需的跳转。
• [LongStorage] tensor:stride() :返回在每个维度中从一个元素到下一个元素所需的跳转。
• [Storage] tensor:storage() :返回用于存储Tensor的所有元素的Storage。 Tensor是查看Storage的一种特殊方式。
• [boolean] tensor:isContiguous() :判断Tensor中存储的元素是否在内存中连续。
• [boolean] tensor:isSize(storage) :判断Tensor与之对应的大小是否匹配。
• [boolean] tensor1:isSameSIzeAs(tensor2) :判断与对应的张量大小是否一致。
• [number] tensor:nElement() :返回张量中元素的个数。
• [numebr] tensor:storageOffset() :返回张量存储中使用的第一个索引（从1开始）。
• [boolean] torch.isTensor(object) :判断object是否为Tensor。

查询元素
Tensor元素实用[index]运算符检索。索引的情况有以下几种情况：
A. 如果index是数字，则[index]运算符等效于tensor:select(1,index)。如果张量具有多个维度，那么此操作运算符返回共享相同基础的张量切片。
B.如果是一个一维张量，它将返回此张量中index处的值。
C.如果index是一个表，则表示必须包含n个数字，其中n是张量的维数。它将在给定的位置返回元素。
D.索引也可以是LongStorage，指定要检索元素的位置，则返回对应元素的值。
E.如果index是每个元素为0或者1的ByteTensor，则它充当用于提取原始张量子集的选择掩码。注意：这对于torch.le 之类的逻辑运算特别有用途。
将张量引用到现有的张量或者内存块
举个例子:

x = torch.Tensor(2,5):fill(3.14)
y = torch.Tensor():set(x)		--注意现在y是x的引用，共享内存位置
y:zero()		--此时，x的所有元素值都为0

基本的设置函数有下列

• [self] tensor1:set(tensor2): 将张量tensor1引用到tensor2，tensor1与tensor2共享内存空间
• [boolean] tensor1:isSetTo(tensor2): 查看张量tensor1是否引用到tensor2
• [self] tensor:set(storage,[storageOffset,sizes,[strides]]): tensor现在将“查看”给定的存储，从位置storageOffset（> = 1）开始，具有给定的sizes和可选的给定strides。
• [self] tensor:set(storage,[storageOffset,sz1[,st1 … [,sz4[,st4]]]]): 这个是前面那个方法的捷径处理方法。它最多可以处理4个size。 szi是张量的第i维的大小。 sti是第i个维度的stride。

举个例子：

s = torch.Storage(10):fill(1)
sz = torch.LongStorage({2,5})
x = torch.Tensor()
x:set(s,1,sz)		-- 将x引用到s存储区域上
print(x)		-- x与s一致
x:zero()		-- 将x全部设置为0
print(s)		-- s也设置为0

拷贝和初始化

• [self] tensor1:copy(tensor2):将tensor2中的元素拷贝到tensor1中。两个tensor中的元素个数必须相同，但是size可以不同。
• [self] tensor:fill(value) 或者是[Tensor] torch.fill(tensor,value)将tensor中的元素由value填充。
• [self] tensor:zero()或者是[Tensor] torch.zero(tensor):将tensor中的元素由0填充。

重新调整大小
当tensor调整为更大的size的时候，基础的Storage将被调整大小以适合Tensor的所有元素。
当调整为较小的size时候，不会调整基础Storage。
注意：调整大小之后的张量内容不确定，因为strides可能已经完全更改。特别地，调整大小的张量的元素在内存中是连续的。

• [self] tensor1:resizeAs(tensor2):将tensor1的大小调整到与tensor2一致的大小，但是必须是同一类型的tensor。
• [self] tensor:resize(sizes):将tensor调整到参数LongStorage指定大小的sizes。
• [self] tensor:resize(sz1[,sz2[,sz3[,sz4]]]):将tensor的size调整到sz1sz2sz3*sz4大小，维度最多达到4。

提取张量
下面的这些方法中的每一个都返回张量，该张量是给定张量的子张量。
对于narrow方法，它返回的张量与原始张量共享内存，因此子张量的内存中的任何修改都会影响到主张量，并没有涉及到内存的复制。
对于其他张量来说，将返回新的张量。

• [self] tensor:narrow(dim,index,size):返回一个新的Tensor，它是当前的Tensor的缩小版本：dim维度从index缩小到index + size-1。
• [self] tensor:sub(dim1s,dim1e … [,dim4s[,dim4e]]): 它返回一个新的Tensor，它是第i维中从索引dimis到dimie的子张量。 负值从末尾开始解释为索引：-1是最后一个索引，-2是最后一个索引之前的索引，…
• [self] tensor:select(dim,index):返回一个新的Tensor，它是维度dim中给定索引处的张量切片。 在第一维上作用select函数等效于使用[]运算符。
• [Tensor] tensor[{dim1,dim2,…}] 或者是 [{{dim1s,dim1e},{dim2s,dim2e}}]:用于张量的切片操作以及取数操作，也可以给对应的子张量值赋值。该运算符还可以使用由带有0和1个元素的ByteTensor组成的输入掩码，例如使用逻辑运算符。
• [Tensor] tensor:index(dim,index) :返回一个新的Tensor，它使用torch.LongTensor index中的条目沿着维度dim索引原始Tensor，返回的Tensor与原始的Tensor具有相同的维度数，并且返回的Tensor和原始的Tensor不共享内存。举个例子

x = torch.rand(5,5)
y = x:index(2,torch.LongTensor({2,3}))
print(x)
print(y)

执行之后的结果为

 0.0161  0.9132  0.9068  0.9236  0.5241
 0.9704  0.4563  0.4754  0.8524  0.2834
 0.6576  0.5215  0.7071  0.8751  0.0855
 0.6051  0.6134  0.8267  0.9284  0.9179
 0.6696  0.1508  0.6858  0.0170  0.8622
[torch.DoubleTensor of size 5x5]

 0.9132  0.9068
 0.4563  0.4754
 0.5215  0.7071
 0.6134  0.8267
 0.1508  0.6858
[torch.DoubleTensor of size 5x2]

注意，显式索引函数与索引运算符[]不同。 索引运算符[]是一系列选择和缩小操作的语法捷径，因此它总是在共享相同存储的原始张量上返回新视图。 但是，显式索引函数不能使用相同的存储。
-[Tensor] tensor1:indexCopy(dim,index,tensor2):通过按index中给定的顺序选择索引，将tensor2的元素复制到tensor1中。 张量的形状必须与索引的元素完全匹配，否则将引发错误。
举个例子

x = torch.rand(5,5)
print(x)
z = torch.Tensor(5,2)
z:select(2,1):fill(-1)
z:select(2,2):fill(-2)
x:indexCopy(2,torch.LongTensor({5,1}),z)
print(x)

执行结果为

 0.4757  0.2340  0.7735  0.5209  0.5927
 0.8747  0.0782  0.2672  0.3411  0.3799
 0.2229  0.2839  0.6602  0.6896  0.0595
 0.0729  0.5929  0.8528  0.4259  0.7970
 0.9171  0.8085  0.5467  0.0962  0.5167
[torch.DoubleTensor of size 5x5]

-2.0000  0.2340  0.7735  0.5209 -1.0000
-2.0000  0.0782  0.2672  0.3411 -1.0000
-2.0000  0.2839  0.6602  0.6896 -1.0000
-2.0000  0.5929  0.8528  0.4259 -1.0000
-2.0000  0.8085  0.5467  0.0962 -1.0000
[torch.DoubleTensor of size 5x5]

• [Tensor]tensor1:indexAdd(dim,index,tensor2):通过按index中给定的顺序添加索引，将tensor2的元素累加到tensor1中。 张量的形状必须与索引的元素完全匹配，否则将引发错误。
• [Tensor] tensor:indexFill(dim,index,val):通过按index中给定的顺序选择索引，用val值填充原始Tensor的元素。
• [Tensor] tensor:gather(dim,index):通过收集每个“行”中的多个值（其中行沿维度为dim）从原始张量创建新的Tensor。 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.

举个例子

x = torch.rand(5,5)
print(x)
y = x:gather(1,torch.LongTensor{{1,2,3,4,5},{2,3,4,5,1}})
z = x:gather(2,torch.LongTensor{{1,2},{2,3},{3,4},{4,5},{5,1}})
print(y)
print(z)

运行结果为

 0.4506  0.7547  0.0269  0.0076  0.5640
 0.2811  0.0191  0.3726  0.9712  0.5816
 0.1447  0.3152  0.2693  0.0051  0.5239
 0.2662  0.6551  0.3129  0.7739  0.0129
 0.6892  0.7909  0.0738  0.3844  0.8121
[torch.DoubleTensor of size 5x5]

 0.4506  0.0191  0.2693  0.7739  0.8121
 0.2811  0.3152  0.3129  0.3844  0.5640
[torch.DoubleTensor of size 2x5]

 0.4506  0.7547
 0.0191  0.3726
 0.2693  0.0051
 0.7739  0.0129
 0.8121  0.6892
[torch.DoubleTensor of size 5x2]

• [Tensor] tensor:scatter(dim,index,src|val):将张量src或标量val中的所有值写入指定索引处的self中。 索引是针对集合中指定的尺寸dim进行指定的。 请注意，对于收集而言，index的值必须在1到self：size（dim）之间（包括两端），并且沿着指定维度的行中的所有值都必须是唯一的。
  举个例子:

x = torch.rand(2,5)
y = torch.zeros(3,5):scatter(1,torch.LongTensor{{1,2,3,1,1},{3,1,1,2,3}},x)
z = torch.zeros(2,4):scatter(2,torch.LongTensor{{3},{4}},1.44)
print(x)
print(y)
print(z)

运行结果为：

 0.2280  0.4189  0.4193  0.4075  0.5191
 0.6016  0.8485  0.2767  0.2743  0.3366
[torch.DoubleTensor of size 2x5]

 0.2280  0.8485  0.2767  0.4075  0.5191
 0.0000  0.4189  0.0000  0.2743  0.0000
 0.6016  0.0000  0.4193  0.0000  0.3366
[torch.DoubleTensor of size 3x5]

 0.0000  0.0000  1.4400  0.0000
 0.0000  0.0000  0.0000  1.4400
[torch.DoubleTensor of size 2x4]

• [Tensor] tensor:maskedSelect(mask) 或者是[Tensor] tensor1:maskedSelect(tensor2,mask):返回一个新的Tensor，其中包含所有与相应mask中的1对齐所有的元素。mask是0和1的torch.ByteTensor。mask和Tensor必须包含有相同数量的元素。生成的Tensor是与Tensor相同类型的一维张量，其大小为mask:sum()
• [Tensor] tensor1:maskedCopy(mask,tensor2):将张量的元素复制到其自身的mask位置中。 被mask的元素是那些在mask Tensor中具有相应1的元素。此掩码是零和一的torch.ByteTensor。 目标Tensor和mask Tensor应具有相同数量的元素。 源张量至少应具有与掩码中的1数量一样多的元素。
  举个例子：

x = torch.rand(4)
mask = torch.ByteTensor({0,1,0,1})
y = torch.Tensor{10,20}
x:maskedCopy(mask,y)
print(x)

x = torch.range(1,4):double():resize(2,2)
mask = torch.ByteTensor{0,0,1,1,0,1,0,1}
y = torch.DoubleTensor(2,4):fill(-1)
y:maskedCopy(mask,x)
print(y)

运行结果为

  0.5683
 10.0000
  0.1836
 20.0000
[torch.DoubleTensor of size 4]

-1 -1  1  2
-1  3 -1  4
[torch.DoubleTensor of size 2x4]

• [Tensor] tensor:maskedFill(mask,val):用值val填充其自身的mask元素。 被mask的元素是那些在mask Tensor中具有相应1的元素。 mask是0和1的torch.ByteTensor。mask和Tensor必须具有相同数量的元素。
  查找
  以下的方法中都返回一个与给定搜索操作的索引相对应的LongTensor。
• [LongTensor] tensor:nonzero() 或者是[LongTensor] torch.nonzero(tensor)：查找并返回与张量中所有非零元素的下标索引对应的LongTensor。请注意，torch调用第一个参数来确定返回类型。由于第一个参数是任何torch.TensorType，但返回类型始终为torch.LongTensor，因此函数调用torch.nonzero(torch.LongTensor(),tensor)不起作用。 但是，tensor.nonzero(torch.LongTensor(),tensor)确实可以工作。

扩展/复制/压缩张量
下面这些方法返回一个通过由原始张量的复制创建的张量。

• [Tensor] torch.expand([tensor,]sizes) 或者是tensor:expand(sizes):大小可以是torch.LongStorage或数字。 扩展张量不会分配新的内存，而只会在现有张量上创建一个新视图，在该张量中，可以通过将跨度设置为0将单例维度扩展为多个维度。任何大小为1的维度都可以扩展为任意值而无需任何新 内存分配。 尝试沿不具有尺寸1的尺寸进行扩展将导致错误。
• [Tensor] tensor1:expandAs(tensor2) 或者是 torch.expandAs(tensor1,tensor2)：相当于函数tensor1:expand(tensor2:size())
• [Tensor] torch.repeatTensor([tensor,]sizes): 大小可以是torch.LongStorage或数字。 重复张量会分配新的内存，除非提供results，在这种情况下，将调整其内存大小。 size指定张量在每个维度中重复的次数。
• [Tensor] torch.squeeze(tensor,dim)或者是tensor:squeeze(dim):删除张量的所有单例尺寸。 如果给定了dim，则仅压缩该张量的特定尺寸。

操纵张量视图
以下的函数中每一个都返回张量，这是查看给定张量存储的另一种方式。 因此，子张量的在内存中的任何修改都会对主张量产生影响，因为它们不涉及任何内存复制，只是对内存的引用。
-[Tensor] torch.view(tensor,sizes)或者是[Tensor]tensor:view(sizes):创建具有与张量关联的存储的不同维度的视图。大小可以是torch.LongStorage或数字。 如果其中一个维度为-1，则从其余元素中推断出该维度的大小。

• [Tensor] torch.viewAs(tensor1,tensor2)或者是[Tensor]tensor1:viewAs(tensor2)：创建一个具有与张量关联的存储模板相同尺寸的视图。
• [Tensor] tensor:transpose(dim1,dim2)：返回一个张量，其中维度dim1和dim2已经交换。二维张量使用tensor:t()与tensor:transpose(1,2)或者tensor:transpose(2,1)等同。
• [Tensor] tensor:permute(dim1,dim2,…,dimn)或者torch.permute(tensor,dim1,dim2,…,dimn):泛化函数transpose()，并且可以用作替换一系列transpose()调用的便捷方法。 返回一个张量，其中尺寸根据(dim1，dim2，…，dimn)给定的排列进行排列。 必须充分指定排列，即必须具有与张量具有尺寸的参数一样多的参数。
• [Tensor] tensor:unfold(dim, size, step): 返回一个张量，其中包含维度为dim的所有大小为size的切片。两个切片之间的步进通过step给出。如果sizeim是dim dim的原始大小，则返回的张量中dim dim的大小将为（sizeim-size）/ step +1。

将函数应用于张量
下面这些函数作用于张量的每个元素成为自身的元素，这些方法要比Lua中使用for循环要快很多。
-[self] tensor:apply(function):将给定的函数应用于self的所有元素。该函数接受一个数字（张量的当前元素），并可能返回一个数字，在这种情况下，它将存储在self中。
举个例子:

local k = 0
local z = torch.Tensor(3,3)
z:apply(function(x)
    k = k + 1
    return k
end)
print(z)
z:apply(math.sin)
print(z)
local sum = 0
z:apply(function(x)
    sum = sum + x
end)
print(sum)
print(z:sum())		--	这样其实和sum的值是一致的

• [self] tensor1:map(tensor2,function(x1,x2)):将给定函数应用于tensor1和tensor2的所有元素。 两个张量的元素数量必须匹配，但是sizes无关紧要。该函数接受两个数字（tensor1和tensor2的当前元素），并且可能返回一个数字，在这种情况下，它将存储在tensor1中。
• [self] tensor1:map2(tensor2,tensor3,function(x1,x2,x3)):将给定函数应用于tensor1,tensor2和tensor3的所有元素。 所有张量的元素数量必须匹配，但size无关紧要。该函数接受三个数字(tensor1,tensor2,tensor3的当前元素)，并可能返回一个数字，在这种情况下，它将存储在tensor1中。

将张量划分为多个张量的表
下面的函数将张量划分为多个张量的表。

• [result] tensor:split(size,dim) 或者是torch.split(tensor,size,dim):将张量沿着维度dim拆分为大小为size或者更小的表result。举个例子

local x = torch.rand(3,4,5)
print(torch.split(x,2,1))
print(x:split(3,2))
print(x:split(2,3))

运行结果为

{
  1 : DoubleTensor - size: 2x4x5
  2 : DoubleTensor - size: 1x4x5
}
{
  1 : DoubleTensor - size: 3x3x5
  2 : DoubleTensor - size: 3x1x5
}
{
  1 : DoubleTensor - size: 3x4x2
  2 : DoubleTensor - size: 3x4x2
  3 : DoubleTensor - size: 3x4x1
}

• [result] torch.chunk(tensor,n,dim)或者[result] tensor:(m,dim):将Tensor张量沿着维度dim分成大小大致相等的n个块，并将它们作为Tensors的result表返回。 参数dim默认为1。内部等价函数为：torch.split(result, tensor, math.ceil(tensor:size(dim)/n), dim)

2 Storage 存储类型

Storage是Tensor对象在内部存储的方式，它是Lua访问C指针或者数组的内存的一种方式。当然也可以将文件内容映射到内存。Storage是基本C类型的数组。对应于基本的Tensor数据类型，基本的存储类型如下表:

浮点数类型	整数类型
torch.DoubleStorage(64位浮点数)	torch.LongStorage(64位有符号整型)
torch.FloatStorage(32位浮点数，默认)	torch.IntStorage(32位有符号整型)
torch.HalfStorage(16位浮点数)	torch.ShortStorage(16位有符号整型)
-	torch.CharStorage(有符号8位整型)
-	torch.ByteStorage(无符号8位整型)

这些类型的对象可序列化，映射的文件也可以序列化。torch.Storage()是默认的存储类型，可以由setdefaulttensortype函数来控制，默认情况下是torch.DoubleStorage

2.1 Storage一些构造函数

• torch.Storage():创建空Storage对象
• torch.Storage(size):创建size大小的Storage
• torch.Storage(table):以一个table创建Storage对象
• torch.Storage(storage,offset,size):返回新的Storage对象，第一个参数必须具有相同的类型。 可以提供一个可选的offset（默认为1）。 还可以提供可选大小来限制新存储的大小，默认为storage:size() -(offset-1)。
• torch.Storage(filename,[,shared[,size[,sharedMem]]]):从文件filename中创建对象Storage。shared参数表示是否共享内存。

2.2 操作函数

• #storage 或者storage:size() :返回Storage的大小。
• storage[index] :返回storage元素的值
• storage:copy(storage) :进行拷贝，有内存副本
• storage:fill(value) :用value填充storage
• storage:resize(size):调整storage大小
• bytestorage:string()或者charstorage:string():将storage转化为string，仅仅针对于ByteStorage和CharStorage
• bytestorage:string(str)或者是charstorage:string(str)：将storage中的元素值表示为字符串中的值。

小结

本小节内容主要学习了一些对Tensor和Storage操作的一些函数等等。需要注意的是，熟练使用一些常见的操作函数。接下来会介绍一些关于Tensor中数学操作的一些函数等等。