Torch7系列教程之Torch深度学习库教程(一)
Torch7深度学习库教程
- 写在前面的话
- torch库
- 1 Tensor库
- 1.1 Tensor数据使用简介
- 1.2 Tensor构造函数
- 1.3 作用于Torch上的一些操作函数
- 2 Storage 存储类型
- 2.1 Storage一些构造函数
- 2.2 操作函数
- 小结
写在前面的话
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.52410.9704 0.4563 0.4754 0.8524 0.28340.6576 0.5215 0.7071 0.8751 0.08550.6051 0.6134 0.8267 0.9284 0.91790.6696 0.1508 0.6858 0.0170 0.8622
[torch.DoubleTensor of size 5x5]0.9132 0.90680.4563 0.47540.5215 0.70710.6134 0.82670.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.59270.8747 0.0782 0.2672 0.3411 0.37990.2229 0.2839 0.6602 0.6896 0.05950.0729 0.5929 0.8528 0.4259 0.79700.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.56400.2811 0.0191 0.3726 0.9712 0.58160.1447 0.3152 0.2693 0.0051 0.52390.2662 0.6551 0.3129 0.7739 0.01290.6892 0.7909 0.0738 0.3844 0.8121
[torch.DoubleTensor of size 5x5]0.4506 0.0191 0.2693 0.7739 0.81210.2811 0.3152 0.3129 0.3844 0.5640
[torch.DoubleTensor of size 2x5]0.4506 0.75470.0191 0.37260.2693 0.00510.7739 0.01290.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.51910.6016 0.8485 0.2767 0.2743 0.3366
[torch.DoubleTensor of size 2x5]0.2280 0.8485 0.2767 0.4075 0.51910.0000 0.4189 0.0000 0.2743 0.00000.6016 0.0000 0.4193 0.0000 0.3366
[torch.DoubleTensor of size 3x5]0.0000 0.0000 1.4400 0.00000.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.568310.00000.183620.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 + 1return 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: 2x4x52 : DoubleTensor - size: 1x4x5
}
{1 : DoubleTensor - size: 3x3x52 : DoubleTensor - size: 3x1x5
}
{1 : DoubleTensor - size: 3x4x22 : DoubleTensor - size: 3x4x23 : 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中数学操作的一些函数等等。
Torch7系列教程之Torch深度学习库教程(一)相关推荐
- python硬件驱动_从零开始：手把手教你安装深度学习操作系统、驱动和各种python库！...
原标题:从零开始:手把手教你安装深度学习操作系统.驱动和各种python库! 为了研究强化学习,最近购置了一台基于 Ubuntu 和英伟达 GPU 的深度学习机器.尽管目前在网络中能找到一些环境部署指 ...
- 手把手教 | 深度学习库PyTorch（附代码）
原文标题: An Introduction to PyTorch – A Simple yet Powerful Deep LearningLibrary 作者:FAIZAN SHAIKH 翻译:和中 ...
- Python机器学习、深度学习库总结（内含大量示例，建议收藏）
Python机器学习.深度学习库总结(内含大量示例,建议收藏) 前言 python常用机器学习及深度学习库介绍 总结与分类 python 常用机器学习及深度学习库总结 分类 更多 前言 目前,随着人工 ...
- 手把手教你用深度学习做物体检测(四)：模型使用
上一篇<手把手教你用深度学习做物体检测(三):模型训练>中介绍了如何使用yolov3训练我们自己的物体检测模型,本篇文章将重点介绍如何使用我们训练好的模型来检测图片或视频中的物体. 如 ...
- Python机器学习、深度学习库总结
Python机器学习.深度学习库总结(内含大量示例,建议收藏) 前言 python常用机器学习及深度学习库介绍 总结与分类 python 常用机器学习及深度学习库总结 分类 更多 前言 为了大家能够对 ...
- 盘点27个机器学习、深度学习库最频繁使用的 Python 工具包（内含大量示例，建议收藏）
目前,随着人工智能的大热,吸引了诸多行业对于人工智能的关注,同时也迎来了一波又一波的人工智能学习的热潮,虽然人工智能背后的原理并不能通过短短一文给予详细介绍,但是像所有学科一样,我们并不需要从头开始& ...
- [PyTroch系列-1]：PyTroch深度学习框架的详细安装过程
作者主页(文火冰糖的硅基工坊):文火冰糖(王文兵)的博客_文火冰糖的硅基工坊_CSDN博客 本文网址:[PyTroch系列-1]:PyTroch深度学习框架的详细安装过程_文火冰糖(王文兵)的博客-C ...
- 【干货小铺】各种编程语言的深度学习库整理
点击上方"小白学视觉",选择加"星标"或"置顶" 重磅干货,第一时间送达本文转自|新机器视觉 本文总结了Python.Matlab.CPP. ...
- 手把手教你安装深度学习软件环境（附代码）
来源:机器之心 本文长度为2800字,建议阅读5分钟. 本文向你解释如何在一台新装的 Ubuntu 机器上安装 Python 和 Nvidia 硬件驱动.各类库和软件包. 为了进行强化学习研究,我最近 ...
最新文章
- Jupyter notebook 的使用
- Kafka-manager启动命令
- SAP-HR三大结构
- 曼彻斯特解密_曼彻斯特编码解码方法与流程
- mysql导入csv大数据
- 使用SAP云平台Portal service的前置条件
- 算法竞赛中的输入输出框架
- python编程语言继承_Python面向对象程序设计类的封装与继承用法示例
- 按职称分类统计人数access_500万人！2021会计职称报考人数要“爆”，通过率或刷新低...
- python基础数据结构,Python基本数据结构
- Java 测试：将用户输入的字符串中的敏感字和谐成星星
- 推荐 浙江省国税vpdn安装正确的方法 如何安装后缀为ocx的控件 由于无法验证发布者 ,所以windows 已经阻止次软件
- vue实现下载pdf文件
- php mp4 ckplayer,织梦dedecms整合添加ckplayer播放器支持flv,mp4等播放功能
- SpringMVC(三) --------- SSM 整合开发案例
- 如何利用导数推导向心加速度公式？ + 开普勒 第三定律的推导过程
- Windows 7 万能驱动下载 免费
- Libcurl最初的实现tfp上传和下载功能
- nodeJS实现牛客网、赛码网在线编程输入输出
- Percona Server 安装