PyTorch学习笔记——（1）系统性的介绍TyTorch的基本操作
目录
- 1、基本数据类型
- 1.1 PyTorch数据类型：
- 1.2 如何检测数据类型：
- 2、创建tensor（张量）
- 2.1 标量
- 2.2 创建张量
- 2.3 创建特定张量
- 3、查看tensor的形状和维度
- （1）`.size(num)`
- （2）`.shape`
- （3）.dim
- 4、tensor的索引
- 5、tensor维度操作
- 5.1 `.view()`：变换维度
- 5.2 `.unsequeeze(dim)`:扩张维度
- 5.3 `.sequeeze()`:维度缩减
- 5.4 `.expand()`:扩展维度
- 5.5 `.repeat()`:复制维度
- 6、交换维度
- 6.1 转置：`.t()`
- 6.2 交换两个维度：`.transpose()`
- 6.3 交换全部维度：`.permute()`
- 7、张量的拼接和拆分
- 7.1 张量的拼接
- （1）`cat(tensors, dim)`：
- （2）`stack(tensors, dim)`：
- 7.2 张量的拆分
- （1）`split([l1,l2,...], dim)`：
- （2）`chunk(num, dim)`：
- 8、tensor的基本运算
- 8.1 广播机制--broadcast
- 8.2 加/减/乘/除
- （1）加：`torch.add()`或者`+`
- （2）减：`torch.sub`或者`-`
- （3）乘：`torch.mul()`或者`*`
- （4）除：`torch.div()`或者`/`
- 8.3 矩阵相乘
- （1）`torch.mm()`:只能是2d的矩阵相乘
- （2）`torch.matmul()`:矩阵相乘，可以是多维的
- （3）`@`：和`torch.matmul()`一样，另一种写法而已
- 8.4 幂和Log运算
- （1）幂：`.pow()`或者`**`
- （2）`.exp()`运算：
- （3）`.log()`运算：
- 8.5 最小值、最大值、均值、总和、累乘
- （1）最小值：`.min(dim)`
- （2）最大值：`.max(dim)`
- （3）均值：`.mean(dim)`
- （4）求总和：`.sum(dim)`
- （5）累乘：`.prod(dim)`
- （6）最小/大值下标：`.argmin(dim)/.argmax(dim)`
- 8.6 `地板除/取余/取商/四舍五入`等操作
- （1）向下取整：`.floor()`
- （2）向上取整：`.ceil()`
- （3）四舍五入：`.round()`
- （4）取整数部分：`.trunc()`
- （5）取小数部分：`.frac()`
- 8.7 `torch.clamp(tensor, min, max)`:压缩张量的值
- 8.8 求范数：`.norm(n)`
- 8.9 返回指定维度上最大/小的前n个数:`.topk(n, dim, largest=False)`
- 8.10 返回第n小的数和下标:`.kthvalue(n, dim)`
- 8.11 比较操作：`<,>,<=,>=,!=,==等等`
- 8.12 比较是否相等：`torch.eq()`/`torch.equal()`
- （1）`torch.eq()`
- （2）`torch.equal()`
1、基本数据类型
下面和python的数据类型作比较，看看PyTorch的数据类型：
字符串类型没有对应？于是使用了下面的方法对应，这个自行搜索。
1.1 PyTorch数据类型：
下图展示了PyTorch的数据类型，需要注意的是CPU和GPU的数据类型是不一样的：
1.2 如何检测数据类型：
方法一：
a = torch.randn(2, 3) #创建一个正态分布的张量
a.type() # 方法一检测
# 输出：
'torch.FloatTensor'
方法二：
type(a) #这个是python中的
# 输出：
torch.Tensor
方法三：
isinstance(a, torch.FloatTensor)
# 输出：
True
# 将数据放到GPU上：
a = a.cuda()
isinstance(a, torch.cuda.FloatTensor)
#输出：
True
2、创建tensor（张量）
2.1 标量
标量就是我们说的单个数字，这个主要的用途是计算Loss的时候使用。下面看看怎么创建的：
import torch
a = torch.tensor(1.) # 创建了一个标量
a
# 输出：
tensor(1.)
# 看看标量的形状：
a.shape # 或者 a.size()
# 输出：
torch.Size([])
2.2 创建张量
在这里为了不涉及更多的知识，我就先直接把张量理解成了数组或者多维矩阵，以后学习的差不多了，再深入理解。
那如何创建呢？下面来看：
- （1）使用：
torch.tensor([])- 注意：使用这个需要加[]，不然就成了标量了。另外，我这里默认创建的数据类型是torch.FloatTensor。
import torch
a = torch.tensor([1.]) # 注意有方括号，省略了就成了标量了
a.shape
# 输出：
torch.Size([1])
a.type() # 我这里默认是torch.FloatTensor
# 输出：
'torch.FloatTensor'
- （2）使用
torch.Tensor()- 注意：这个大写的Tensor和前面小写的区别是：这个不加[]创建一个随机化的张量，并且括号里的参数是形状；加了[]则表明里面的数据，和tensor一个功能了。
# 情况一：
torch.Tensor(2,3) # 创建形状为(2, 3)的张量
# 输出：
tensor([[0.0000e+00, 0.0000e+00, 1.4013e-45],
[0.0000e+00, 1.4013e-45, 0.0000e+00]])
# 情况二：
torch.Tensor([2,3]) # 创建[2,3]这个张量
# 输出：
tensor([2., 3.])
- （3）
torch.FloatTensor()- 这个和torch.Tensor类似，只不过指定了类型。
a = torch.FloatTensor(2,3)
a.shape
# 输出：
torch.Size([2, 3])
关于其他类型，和（2）（3）情况差不多，这里就不再赘述了。
2.3 创建特定张量
- （1）创建全为1的张量：
torch.ones()或者torch.ones_like()
例子：
a = torch.ones(2,2)
# 输出：
tensor([[1., 1.],
[1., 1.]])
torch.ones_like(a) # 就是按a的形状，创造全1的张量
# 输出：
tensor([[1., 1.],
[1., 1.]])
- (2)创建全为0的张量：
torch.zeros()或torch.zeros_like()
例子：
a = torch.zeros(3,2)
# 输出:
tensor([[0., 0.],
[0., 0.],
[0., 0.]])
torch.zeros_like(a)# 就是按a的形状，创造全0的张量
# 输出:
tensor([[0., 0.],
[0., 0.],
[0., 0.]])
- (3)创建指定数字的张量：
torch.full([], num)- []里面是指定的形状，num是用哪个数字填充
例子：
torch.full([2,3], 7)
# 输出：
tensor([[7., 7., 7.],
[7., 7., 7.]])
- (4)从numpy创建：
torch.from_numpy(data)
例子：
data = np.ones(2)
torch.from_numpy(data) # 将numpy的数组类型转换为tensor
# 输出：
tensor([1., 1.], dtype=torch.float64)
- （5）从list导入：
a = [1,2,3]
torch.tensor(a) # 注意：小写的tensor接受数据，大写的接受shape
# 输出：
tensor([1, 2, 3])
- （6）生成未初始化的tensor：
torch.empty()
例子：
torch.empty(2,3) # 2行3列
# 输出：
tensor([[1.3541e-05, 8.5007e-07, 8.4078e-45],
[0.0000e+00, 1.4013e-45, 0.0000e+00]])
注意：这个其实就随机初始化了，有时候初始化的值很大或者很小，所以尽量少用。
- （7）生成序列：
arange()，和python的range一样，不赘述。
例子：
torch.arange(10,1, -1) # 生成从10到1的整数,第三个参数为间隔，-1为倒着来
- （8）
linspace()/logspace()linspace()在一个给定的区间中，将这个区间平均分成几份。logspace()就是开始结束的10次方，然后在这个区间中均匀取点
例子：
torch.linspace(0, 10, 4) # 把1-10平均分成4份了
# 输出：
tensor([ 0.0000, 3.3333, 6.6667, 10.0000])
torch.logspace(0, 10, 5) # 就是开始结束的10次方，然后在这个区间中均匀取点
# 输出：
tensor([1.0000e+00, 3.1623e+02, 1.0000e+05, 3.1623e+07, 1.0000e+10])
- （9）生成单位矩阵：
eye()
例子：
a = torch.eye(3,3) # 3*3单位矩阵
# 输出：
tensor([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
- (10)生成从0到n-1的的n个数，然后打乱：
torch.randperm(n)
例子：
torch.randperm(9)
# 输出：
tensor([0, 6, 3, 4, 8, 7, 1, 5, 2])
3、查看tensor的形状和维度
（1）.size(num)
功能是查看张量的形状。
参数：num指查看第几个维度，缺失默认全部
返回值为张量的形状，从外到内（我指的是[]从外到内）。
例子：
a = torch.randn(2, 3) # 使用正态分布随机初始化2*3列的张量
a.size() # 查看张量的形状，从外到内
# 输出：
torch.Size([2, 3])
a.size(0) # 第0维度的张量大小
# 输出：
2
a.size(1) # 第1维度的张量大小
# 输出：
3
（2）.shape
和size()一个效果。
例子：
a = torch.randn(2, 3) # 使用正态分布随机初始化2*3列的张量
a.shape # 和size一个效果
# 输出：
torch.Size([2, 3])
a.shape[0] # 查看第0维度
# 输出：
2
a.shape[1] # 查看第0维度
# 输出：
3
（3）.dim
功能：查看张量有几个维度。
例子：
a = torch.randn(2, 3) # 使用正态分布随机初始化2*3列的张量
a.dim
# 输出：
2
4、tensor的索引
- （1）比如要直接取一个张量里的某个数，直接看例子：
a = torch.randn(4, 3, 28, 28) # 创建了(4,3,28,28)形状的张量
a.shape
# 输出：
torch.Size([4, 3, 28, 28])
# 取第一个维度为0，第二个维度为0，第三个维度为2，第四个维度为4的数：
a[0, 0, 2, 4] # 返回的是标量哦
# 输出：
tensor(-0.2821)
- （2）下标切片：和python切片一样，使用冒号:来切片每一个维度的数据，需要注意的是冒号后面的数是不包括的。
需求：取第一个维度的前两行，第二个维度的前两行，后两个维度的全部数据。直接看例子：
a = torch.randn(4, 3, 28, 28) # 创建了(4,3,28,28)形状的张量
# 方法一：
a[:2, :2, :, :].shape # 这个操作就直接完成需求
# 输出：
torch.Size([2, 2, 28, 28])
# 方法二：
a[:2, :2].shape # 后面的冒号也可以省略
# 输出：
torch.Size([2, 2, 28, 28])
- （3）隔行采样：使用
a:b:c这样的样式来完成操作，其中c表示隔几个数。- 注意：a,b都省略表示全选
例子：
a = torch.randn(4, 3, 28, 28) # 创建了(4,3,28,28)形状的张量
a[:,:,::2,::2].shape # 隔行采样,
# 输出：
torch.Size([4, 3, 14, 14])
- （4）使用
...代替多个:
例子：
a[0:1, ...].shape # 等价于a[0,1,:,:]
# 输出：
torch.Size([1, 3, 28, 28])
5、tensor维度操作
5.1 .view()：变换维度
例子：
a = torch.randn(4,1,28,28)
a.view(4, -1).shape # -1表示自适应
# 输出：
torch.Size([4, 784])
5.2 .unsequeeze(dim):扩张维度
注意：dim表示在这个维度前面插入1个维度，这个维度的大小为1.
例子：
b = torch.randn(32)
b = b.unsqueeze(0)
b.shape
# 输出：
torch.Size([1, 32])
5.3 .sequeeze():维度缩减
注：这个就是把维度为1的维度删掉，不指定维度，则全删掉，指定了就删除那一个维度。
例子：
b = torch.randn(1,32,1,1)
b.sequeeze().shape
# 输出：
torch.Size([32])
5.4 .expand():扩展维度
作用是将原来张量中，维度为1的扩展为expand()指定的维度。
注意：要是原来的张量的某个维度不为1，则在expand()中要保持原来的数不变。
例子：
b = torch.randn(1,32,1,1)
b.expand(4,32,4,4).shape # 扩展维度,注意：32不能变
# 输出：
torch.Size([4, 32, 4, 4])
5.5 .repeat():复制维度
作用是将原来张量的每个维度扩展指定的倍数。
例子：
b = torch.randn(1,32,1,1)
b.repeat(4,4,4,4).shape # 复制维度，每个维度都扩展4倍
# 输出：
torch.Size([4, 128, 4, 4])
6、交换维度
6.1 转置：.t()
c = torch.randn(2,3)
c.t().shape
# 输出：
torch.Size([3, 2])
6.2 交换两个维度：.transpose()
交换某两个维度，直接看例子：
a = torch.randn(4,1,28,28)
a.transpose(0, 1).shape #0维度和1维度交换
# 输出:
torch.Size([1, 4, 28, 28])
6.3 交换全部维度：.permute()
permute()和transpose()的不同之处在于，这个每次要给出全部的维度，也就是一次交换成功。
例子：
a = torch.randn(4,1,28,28)
a.permute(0,2,3,1).shape # 把要交换的维度放到对应的位置上
# 输出;
torch.Size([4, 28, 28, 1])
7、张量的拼接和拆分
7.1 张量的拼接
（1）cat(tensors, dim)：
功能是：按照某个维度将两个或者多个张量拼接成一个张量。
注意：拼接的维度可以不同，但其他维度必须相同
例子：
# 创建a,b张量
a = torch.randn(4, 32, 8)
b = torch.randn(5, 32, 8)
torch.cat([a,b], dim=0).shape # 在0维度进行拼接
# 输出：
torch.Size([9, 32, 8])
#注意：不能在1，2维度上拼接，因为拼接的维度可以不同，但其他维度必须相同
（2）stack(tensors, dim)：
功能：沿着一个新的维数串联张量序列，所有的张量必须是相同的大小。这个和cat()的不同之处在于新增加了一个维度，新增的维度的位置就是dim，而原来的维度向后推。
注意：所有的维度都必须相同
例子：
a = torch.randn(32,8)
b = torch.randn(32,8)
torch.stack([a,b],dim=2).shape # 在2维上进行串联
# 输出：
torch.Size([32, 8, 2])
7.2 张量的拆分
（1）split([l1,l2,...], dim)：
功能：在指定维度上，按长度拆分，第一个参数为划分的长度，是个列表，第二个参数为指定的维度
例子：
# 创建a,b张量
a = torch.randn(32,8)
b = torch.randn(32,8)
c = torch.stack([a,b], dim=0) # 在0维度串联一下张量
c.shape
# 输出：
torch.Size([2, 32, 8])
aa, bb = c.split([2, 6], dim=2) # 在2维度上进行分割，[2，6]就是切分后两个张量2维度的长度
aa.shape
# 输出：
torch.Size([2, 32, 2])
bb.shape
# 输出：
torch.Size([2, 32, 6])
（2）chunk(num, dim)：
功能：按数量拆分，第一个参数为拆分成几个，第二个参数为指定的维度
例子：
a = torch.randn(2,32,8)
aa, bb, cc= a.chunk(3, dim=1) # 这个在1维度上，拆分成3份
aa.shape
# 输出：
torch.Size([2, 11, 8])
bb.shape
# 输出：
torch.Size([2, 11, 8])
cc.shape
# 输出：
torch.Size([2, 10, 8])
8、tensor的基本运算
8.1 广播机制–broadcast
在介绍基本运算之前，先需要了解张量的广播机制，下面来看什么是广播机制以及如何判断两个张量能够使用广播机制。
数组在进行矢量化运算时，要求数组的形状是相等的。当形状不相等的数组执行算术运算的时候，就会出现广播机制，该机制会对数组进行扩展，使数组的shape属性值一样，这样，就可以进行矢量化运算了。下面通过一个例子进行说明：
例子:
c = torch.randn(4,32,8)
d = torch.tensor(5)
(c+d).shape
# 输出：
torch.Size([4, 32, 8])
发现d这个张量被扩展了，这个就是广播机制。
如何判断两个张量能够被广播了？
答：
广播机制首先需要判断参与计算的两个数组能否被广播机制处理？即判断是否广播兼容，规则是，比较两个数组的shape，从shape的尾部开始一一比对。
-
(1). 如果两个数组的维度相同，对应位置上轴的长度相同或其中一个的轴长度为1,广播兼容，可在轴长度为1的轴上进行广播机制处理。
-
(2). 如果两个数组的维度不同，那么给低维度的数组前扩展提升一维，扩展维的轴长度为1,然后在扩展出的维上进行广播机制处理
其实就是：
每一维度要么是1，要么是相同，才能完成广播机制，否则不行。
注意：从最后一维匹配。
8.2 加/减/乘/除
（1）加：torch.add()或者+
例子：
a = torch.randn(3,4)
b = torch.randn(4)
# 方法一：
a+b
# 输出：
tensor([[ 3.1385, -2.8180, -2.4045, -1.1223],
[ 2.6021, -1.8846, 0.0730, -1.1969],
[ 1.1122, -1.8775, -0.3526, -0.4563]])
# 方法二：
torch.add(a, b)
# 输出：
tensor([[ 3.1385, -2.8180, -2.4045, -1.1223],
[ 2.6021, -1.8846, 0.0730, -1.1969],
[ 1.1122, -1.8775, -0.3526, -0.4563]])
# 测试这两种方法是否相同
torch.all(torch.eq(a+b, torch.add(a, b))) # 返回1，说明相同
# 输出：
tensor(1, dtype=torch.uint8) # 说明相同
（2）减：torch.sub或者-
例子：
a = torch.randn(3,4)
b = torch.randn(4)
# 方法一：
a-b
# 输出：
tensor([[ 1.5512, 0.4216, 1.7395, -1.6961],
[-1.6746, -0.1539, 1.2162, -0.1148],
[ 0.7890, 1.4086, 0.6567, -0.0117]])
# 方法二：
torch.sub(a, b)
# 输出：
tensor([[ 1.5512, 0.4216, 1.7395, -1.6961],
[-1.6746, -0.1539, 1.2162, -0.1148],
[ 0.7890, 1.4086, 0.6567, -0.0117]])
# 测试两种是否相同：
torch.all(torch.eq(a-b, torch.sub(a, b))) # 返回1，说明相同
# 输出:
tensor(1, dtype=torch.uint8) # 说明相同
（3）乘：torch.mul()或者*
例子：
a = torch.randn(3,4)
b = torch.randn(4)
# 方法一：
a*b
# 输出：
tensor([[-1.2945, -0.0145, -0.6984, -0.0912],
[-1.0029, 0.1125, -0.5314, -0.0523],
[ 0.0383, 0.2164, 0.5210, -0.2775]])
# 方法二：
torch.mul(a, b)
# 输出：
tensor([[-1.2945, -0.0145, -0.6984, -0.0912],
[-1.0029, 0.1125, -0.5314, -0.0523],
[ 0.0383, 0.2164, 0.5210, -0.2775]])
# 测试两种是否想同：
torch.all(torch.eq(a*b, torch.mul(a,b))) # 返回1，说明相同
# 输出：
tensor(1, dtype=torch.uint8) # 说明相同
（4）除：torch.div()或者/
例子：
a = torch.randn(3,4)
b = torch.randn(4)
# 方法一：
a/b
# 输出：
tensor([[ 1.3383, 0.8219, -0.1636, 3.3313],
[-0.9232, -0.6466, -0.2253, -2.2406],
[ 1.5990, 0.1215, 1.5978, -0.9182]])
# 方法二：
torch.div(a, b)
# 输出：tensor([[ 1.3383, 0.8219, -0.1636, 3.3313],
[-0.9232, -0.6466, -0.2253, -2.2406],
[ 1.5990, 0.1215, 1.5978, -0.9182]])
# 测试两者是否相同：
torch.all(torch.eq(a/b, torch.div(a, b))) # 返回1，说明相同
# 输出：
tensor(1, dtype=torch.uint8) # 说明相同
8.3 矩阵相乘
（1）torch.mm():只能是2d的矩阵相乘
矩阵乘法我就不说了，大学知识。直接看例子：
a = torch.full([3,3], 3)
b = torch.ones(3,2)
torch.mm(a, b) # 矩阵a与矩阵b相乘
# 输出：
tensor([[9., 9.],
[9., 9.],
[9., 9.]])
（2）torch.matmul():矩阵相乘，可以是多维的
先看一下API怎么用的，然后再看是怎么相乘的。直接看例子：
a = torch.full([2, 2], 3)
b = torch.ones(2, 3)
torch.matmul(a, b)
# 输出：
tensor([[6., 6., 6.],
[6., 6., 6.]])
如果是多维的张量，那是怎么运算的呢？
答：
torch.matmul()多维是如何运算的：取最后的两维进行运算（要符合矩阵的乘法的维度），之前的维度要符合广播机制，不然就不要能运算。
（3）@：和torch.matmul()一样，另一种写法而已
例子：
a = torch.full([2, 2], 3)
b = torch.ones(2, 3)
a@b
# 输出：
tensor([[6., 6., 6.],
[6., 6., 6.]])
8.4 幂和Log运算
（1）幂：.pow()或者**
例子：
a = torch.full([2, 2], 3)
# 方法一：
a**2
# 输出：
tensor([[9., 9.],
[9., 9.]])
# 方法二：
a.pow(2)
# 输出:
tensor([[9., 9.],
[9., 9.]])
# 测试两者是否相同
torch.all(torch.eq(a**2, a.pow(2))) # 返回1，表示相同
tensor(1, dtype=torch.uint8) # 说明相同
（2）.exp()运算：
就是将矩阵的每个元素的值放在e的次方上。
例子：
a = torch.ones(2,2)
torch.exp(a)
# 输出：
tensor([[2.7183, 2.7183],
[2.7183, 2.7183]])
（3）.log()运算：
将张量里面每个元素的值放在Log上（以e为底）。
例子：
a = torch.ones(2,2)
torch.log(torch.exp(a)) # 每个元素的值放在Log上（以e为底）。
# 输出：
tensor([[1., 1.],
[1., 1.]])
8.5 最小值、最大值、均值、总和、累乘
（1）最小值：.min(dim)
求指定维度的最小值，不指定就是全部元素的最小值。
例子：
a = torch.randn(2,3)
a.min() # 求元素的最小值
# 输出：
tensor(-0.8424)
（2）最大值：.max(dim)
求指定维度的最大值，不指定就是全部元素的最大值。
例子：
a = torch.randn(2,3)
a.max() # 求元素的最大值
# 输出：
tensor(0.6582)
（3）均值：.mean(dim)
求指定维度的均值，如果不指定维度，那就是先摊平，再求均值。
例子：
a = torch.arange(8).view(2,4).float()
a
tensor([[0., 1., 2., 3.],
[4., 5., 6., 7.]])
a.mean() # 求均值,不指定维度，那就是先摊平，再求均值
# 输出：
tensor(3.5000)
a.mean(dim=0)
# 输出：
tensor([2., 3., 4., 5.])
a.mean(dim=1)
# 输出：
tensor([1.5000, 5.5000])
（4）求总和：.sum(dim)
a = torch.arange(8).view(2,4).float()
a
tensor([[0., 1., 2., 3.],
[4., 5., 6., 7.]])
a.sum() # 求总和，不指定维度则摊平再求和
# 输出：
tensor(28.)
（5）累乘：.prod(dim)
例子：
b = torch.arange(1,9).view(2,4)
b
tensor([[1, 2, 3, 4],
[5, 6, 7, 8]])
b.prod()
# 输出：
tensor(40320)
b.prod(dim=0)
# 输出：
tensor([ 5, 12, 21, 32])
（6）最小/大值下标：.argmin(dim)/.argmax(dim)
不指定维度，先摊平再求最小/大值的下标。
例子：
a = tensor([[0., 1., 2., 3.],
[4., 5., 6., 7.]])
a.argmin() # 不指定维度，先摊平再求最小值的下标
# 输出：
tensor(0)
a.argmax()# 不指定维度，先摊平再求最大值的下标
# 输出：
tensor(7)
8.6 地板除/取余/取商/四舍五入等操作
（1）向下取整：.floor()
例子：
b=tensor([[-0.4939, -0.2635, -1.2792],
[ 1.2397, -0.5633, -0.5897]])
b.floor()
# 输出：
tensor([[-1., -1., -2.],
[ 1., -1., -1.]])
（2）向上取整：.ceil()
例子：
b=tensor([[-0.4939, -0.2635, -1.2792],
[ 1.2397, -0.5633, -0.5897]])
b.ceil()
# 输出：
tensor([[-0., -0., -1.],
[ 2., -0., -0.]])
（3）四舍五入：.round()
例子：
b=tensor([[-0.4939, -0.2635, -1.2792],
[ 1.2397, -0.5633, -0.5897]])
b.round()
# 输出：
tensor([[-0., -0., -1.],
[ 1., -1., -1.]])
（4）取整数部分：.trunc()
例子：
b=tensor([[-0.4939, -0.2635, -1.2792],
[ 1.2397, -0.5633, -0.5897]])
b.trunc()
# 输出：
tensor([[-0., -0., -1.],
[ 1., -0., -0.]])
（5）取小数部分：.frac()
例子：
b=tensor([[-0.4939, -0.2635, -1.2792],
[ 1.2397, -0.5633, -0.5897]])
b.frac()
# 输出：
tensor([[-0.4939, -0.2635, -0.2792],
[ 0.2397, -0.5633, -0.5897]])
8.7 torch.clamp(tensor, min, max):压缩张量的值
功能：将输入张量每个元素的值夹紧到区间 [min,max]，并返回结果到一个新张量。
注：小于最小值的直接变成最小值，大于最大值的，变成最大值，在中间的则不变。
例子：
b=tensor([[-0.4939, -0.2635, -1.2792],
[ 1.2397, -0.5633, -0.5897]])
torch.clamp(b, min=1, max=2)
# 输出：
tensor([[1.0000, 1.0000, 1.0000],
[1.2397, 1.0000, 1.0000]])
8.8 求范数：.norm(n)
n为要求几范数。
例子：
a = torch.full([8], 1)
a
tensor([1., 1., 1., 1., 1., 1., 1., 1.])
b = a.view(2, 4)
b
tensor([[1., 1., 1., 1.],
[1., 1., 1., 1.]])
c = a.view(2,2,2)
c
tensor([[[1., 1.],
[1., 1.]],
[[1., 1.],
[1., 1.]]])
a.norm(1),b.norm(1),c.norm(1) # 求1范数
# 输出：
(tensor(8.), tensor(8.), tensor(8.))
a.norm(2),b.norm(2),c.norm(2) # 求2范数
# 输出：
(tensor(2.8284), tensor(2.8284), tensor(2.8284))
8.9 返回指定维度上最大/小的前n个数:.topk(n, dim, largest=False)
注：largest=False则是求最小的前n个数，不写则为最大的前n个数。
例子：
a = tensor([[0., 1., 2., 3.],
[4., 5., 6., 7.]])
a.topk(3, dim=1) # 求前三大
# 输出：
torch.return_types.topk(
values=tensor([[3., 2., 1.],
[7., 6., 5.]]),
indices=tensor([[3, 2, 1],
[3, 2, 1]]))
a.topk(3, largest=False) # 求最小的三个
# 输出：
torch.return_types.topk(
values=tensor([[0., 1., 2.],
[4., 5., 6.]]),
indices=tensor([[0, 1, 2],
[0, 1, 2]]))
8.10 返回第n小的数和下标:.kthvalue(n, dim)
例子：
a = tensor([[0., 1., 2., 3.],
[4., 5., 6., 7.]])
a.kthvalue(3) # 返回第三小的数
# 输出：
torch.return_types.kthvalue(
values=tensor([2., 6.]),
indices=tensor([2, 2]))
8.11 比较操作：<,>,<=,>=,!=,==等等
这个比较简单，我只举一个例子
a = tensor([[0., 1., 2., 3.],
[4., 5., 6., 7.]])
a > 0 # 返回False和True
# 输出：
tensor([[False, True, True, True],
[ True, True, True, True]])
torch.gt(a, 0) # 和a>0一个效果
# 输出：
tensor([[False, True, True, True],
[ True, True, True, True]])
8.12 比较是否相等：torch.eq()/torch.equal()
（1）torch.eq()
返回每个元素对应位置是否相等。
例子：
a = tensor([[0., 1., 2., 3.],
[4., 5., 6., 7.]])
b = a
torch.eq(a, b) # 返回都为True，说明相同
tensor([[True, True, True, True],
[True, True, True, True]])
（2）torch.equal()
检测两个张量是否相同，返回真或者假。
例子：
torch.equal(a,b) # 返回True，说明a和b相等
# out:
True