pytorch张量 张量计算

最新推荐文章于 2024-04-05 12:26:06 发布
最新推荐文章于 2024-04-05 12:26:06 发布
阅读量4.4k 收藏 26
点赞数 2
分类专栏： pytorch 文章标签： pytorch 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhhhxxn/article/details/110119567
版权
一、比较大小

在这里插入图片描述
torch.allclose()函数，比较两个元素是否接近，比较A和B是否接近的公式为
|A-B| <= atol+rtol*|B|

import torch
A = torch.tensor([10.0])
B = torch.tensor([10.1])
print(torch.allclose(A,B,rtol=1e-05,atol=1e-08,equal_nan =False))
print(torch.allclose(A,B,rtol=0.1,atol=0.01,equal_nan = False))
# False
# True
#在不同的比较标准下，10和1.1是否接近有着不同的结果


#如果equal_nan=True，那么缺失值之间可以判定为接近
A = torch.tensor(float("nan"))
print(torch.allclose(A,A,equal_nan = False))
print(torch.allclose(A,A,equal_nan = True))
# False
# True

torch.eq()函数
torch.equal()函数

import torch
A = torch.tensor([1,2,3,4,5,6])
B = torch.arange(1,7)
C = torch.unsqueeze(B,dim = 0)
print(torch.eq(A,B))
print(torch.eq(A,C))
# tensor([True, True, True, True, True, True])
# tensor([[True, True, True, True, True, True]])

print(torch.equal(A,B))
print(torch.equal(A,C))
# True
# False

torch.ge()函数
torch.gt()函数

import torch
A = torch.tensor([1,2,3,4,5,6])
B = torch.arange(1,7)
C = torch.unsqueeze(B,dim = 0)

print(torch.ge(A,B))
print(torch.ge(A,C))
# tensor([True, True, True, True, True, True])
# tensor([[True, True, True, True, True, True]])

print(torch.gt(A,B))
print(torch.gt(A,B))
# tensor([False, False, False, False, False, False])
# tensor([False, False, False, False, False, False])

torch.le()函数
torch.lt()函数

import torch
A = torch.tensor([1,2,3,4,5,6])
B = torch.arange(1,7)
C = torch.unsqueeze(B,dim = 0)

print(torch.le(A,B))
print(torch.le(A,C))
# tensor([True, True, True, True, True, True])
# tensor([[True, True, True, True, True, True]])

print(torch.lt(A,B))
print(torch.lt(A,C))
# tensor([False, False, False, False, False, False])
# tensor([[False, False, False, False, False, False]])

torch.ne()函数
torch.isnan()函数

import torch
A = torch.tensor([1,2,3,4,5,6])
B = torch.arange(1,7)
C = torch.unsqueeze(B,dim = 0)

print(torch.ne(A,B))
print(torch.ne(A,C))
# tensor([False, False, False, False, False, False])
# tensor([[False, False, False, False, False, False]])

torch.isnan(torch.tensor([0,1,float("nan"),2]))
# tensor([False, False,  True, False])
二、基本运算
逐元素运算

基本运算

import torch
A = torch.arange(6.0).reshape(2,3)
B = torch.linspace(10,20,steps = 6).reshape(2,3)
print("A:",A)
# A: tensor([[0., 1., 2.],
#         [3., 4., 5.]])

print("B",B)
# B tensor([[10., 12., 14.],
#         [16., 18., 20.]])

##加减乘除四则运算
print(A*B)
# tensor([[  0.,  12.,  28.],
#         [ 48.,  72., 100.]])

print(A/B)
# tensor([[0.0000, 0.0833, 0.1429],
#         [0.1875, 0.2222, 0.2500]])

print(A+B)
# tensor([[10., 13., 16.],
#         [19., 22., 25.]])

print(A-B)
# tensor([[-10., -11., -12.],
#         [-13., -14., -15.]])

print(B//A)
# tensor([[inf, 12.,  7.],
#         [ 5.,  4.,  4.]])

##幂运算
print(torch.pow(A,3))
print(A**3)
# tensor([[  0.,   1.,   8.],
#         [ 27.,  64., 125.]])
# tensor([[  0.,   1.,   8.],
#         [ 27.,  64., 125.]])

##指数运算
print(torch.exp(A))
# tensor([[  1.0000,   2.7183,   7.3891],
#         [ 20.0855,  54.5981, 148.4132]])

##对数运算
print(torch.log(A))
# tensor([[  -inf, 0.0000, 0.6931],
#         [1.0986, 1.3863, 1.6094]])

##平方根
print(torch.sqrt(A))
print(A**0.5)
# tensor([[0.0000, 1.0000, 1.4142],
#         [1.7321, 2.0000, 2.2361]])
# tensor([[0.0000, 1.0000, 1.4142],
#         [1.7321, 2.0000, 2.2361]])


##张量的平方根的倒数
print(torch.rsqrt(A))
print(1/(A**0.5))
# tensor([[   inf, 1.0000, 0.7071],
#         [0.5774, 0.5000, 0.4472]])
# tensor([[   inf, 1.0000, 0.7071],
#         [0.5774, 0.5000, 0.4472]])

张量数据裁剪
根据最大值裁剪 torch.clamp_max()
根据最小值裁剪 torch.clamp_min()
根据范围裁剪 torch.clamp()

import torch
A = torch.arange(6.0).reshape(2,3)
B = torch.linspace(10,20,steps = 6).reshape(2,3)
print("A:",A)
# A: tensor([[0., 1., 2.],
#         [3., 4., 5.]])


torch.clamp_max(A,4)
# tensor([[0., 1., 2.],
#         [3., 4., 4.]])

torch.clamp_min(A,3)
# tensor([[3., 3., 3.],
#         [3., 4., 5.]])

torch.clamp(A,2.5,4)
# tensor([[2.5000, 2.5000, 2.5000],
#         [3.0000, 4.0000, 4.0000]])

对于矩阵的运算

import torch
A = torch.arange(6.0).reshape(2,3)
B = torch.linspace(10,20,steps = 6).reshape(2,3)
print("A:",A)
# A: tensor([[0., 1., 2.],
#         [3., 4., 5.]])

print("B",B)
# B tensor([[10., 12., 14.],
#         [16., 18., 20.]])

##矩阵的转置
C = torch.t(A)
C
# tensor([[0., 3.],
#         [1., 4.],
#         [2., 5.]])

##矩阵相乘
A.matmul(C)
# tensor([[ 5., 14.],
#         [14., 50.]])

A = torch.arange(12.0).reshape(2,2,3)
B = torch.arange(12.0).reshape(2,3,2)
AB = torch.matmul(A,B)
print(A)
# tensor([[[ 0.,  1.,  2.],
#          [ 3.,  4.,  5.]],

#         [[ 6.,  7.,  8.],
#          [ 9., 10., 11.]]])
print(B)
# tensor([[[ 0.,  1.],
#          [ 2.,  3.],
#          [ 4.,  5.]],

#         [[ 6.,  7.],
#          [ 8.,  9.],
#          [10., 11.]]])
AB
# tensor([[[ 10.,  13.],
#          [ 28.,  40.]],

#         [[172., 193.],
#          [244., 274.]]])

##矩阵相乘只计算后边两个维度的乘法
print(AB[0].eq(torch.matmul(A[0],B[0])))
print(AB[1].eq(torch.matmul(A[1],B[1])))
# tensor([[True, True],
#         [True, True]])
# tensor([[True, True],
#         [True, True]])

##矩阵的逆
C = torch.rand(3,3)
print(C)
# tensor([[0.9568, 0.8140, 0.4885],
#         [0.5586, 0.7726, 0.6561],
#         [0.1674, 0.9509, 0.8874]])
D = torch.inverse(C)
print(D)
# tensor([[ -1.0509,   4.3900,  -2.6674],
#         [  6.5686, -13.0628,   6.0425],
#         [ -6.8405,  13.1696,  -4.8448]])
torch.mm(C,D)
# tensor([[ 1.0000e+00, -4.8042e-07, -1.1227e-07],
#         [-3.3606e-07,  1.0000e+00, -4.4348e-07],
#         [-4.2905e-07,  4.1309e-07,  1.0000e+00]])
##torch.mm()是矩阵相乘
##torch.mul()是对应元素相乘
三、统计相关的计算

最大值最小值

import torch
A= torch.tensor([12.,34,25,11,67,32,29,30,99,55,23,44])

###一维张量的最大值最小值
print("最大值：",A.max())
print("最大值位置：",A.argmax())
print("最小值：",A.min())
print("最小值位置：",A.argmin())
# 最大值： tensor(99.)
# 最大值位置： tensor(8)
# 最小值： tensor(11.)
# 最小值位置： tensor(3)

##二维张量的最大值最小值
B = A.reshape(3,4)
print("B",B)
print("每一行最大值：",B.max(dim = 1))
print("最大值位置：",B.argmax(dim =1))
print("每一列最小值：",B.min(dim =0))
print("最小值位置：",B.argmin(dim = 0))
# B tensor([[12., 34., 25., 11.],
#         [67., 32., 29., 30.],
#         [99., 55., 23., 44.]])
# 每一行最大值： torch.return_types.max(
# values=tensor([34., 67., 99.]),
# indices=tensor([1, 0, 0]))
# 最大值位置： tensor([1, 0, 0])
# 每一列最小值： torch.return_types.min(
# values=tensor([12., 32., 23., 11.]),
# indices=tensor([0, 1, 2, 0]))
# 最小值位置： tensor([0, 1, 2, 0])

排序

import torch
A= torch.tensor([12.,34,25,11,67,32,29,30,99,55,23,44])

##由小到大排序，以及相应元素在原始位置的索引
torch.sort(A)
# torch.return_types.sort(
# values=tensor([11., 12., 23., 25., 29., 30., 32., 34., 44., 55., 67., 99.]),
# indices=tensor([ 3,  0, 10,  2,  6,  7,  5,  1, 11,  9,  4,  8]))

##由大到小排序
torch.sort(A,descending = True)
# torch.return_types.sort(
# values=tensor([99., 67., 55., 44., 34., 32., 30., 29., 25., 23., 12., 11.]),
# indices=tensor([ 8,  4,  9, 11,  1,  5,  7,  6,  2, 10,  0,  3]))

##二维张量排序，对每一行进行排序
B = A.reshape(3,4)
print("B:\n",B)
Bsort,Bsort_id = torch.sort(B)
print("Bsort:\n",Bsort)
print("Bsort index: \n",Bsort_id)
print("Bargsort:\n",torch.argsort(B))
# B:
#  tensor([[12., 34., 25., 11.],
#         [67., 32., 29., 30.],
#         [99., 55., 23., 44.]])
# Bsort:
#  tensor([[11., 12., 25., 34.],
#         [29., 30., 32., 67.],
#         [23., 44., 55., 99.]])
# Bsort index: 
#  tensor([[3, 0, 2, 1],
#         [2, 3, 1, 0],
#         [2, 3, 1, 0]])
# Bargsort:
#  tensor([[3, 0, 2, 1],
#         [2, 3, 1, 0],
#         [2, 3, 1, 0]])

torch.topk()前k大的数值及其所在位置
torch.kthvalue()第k小的数值及其所在位置

import torch
A= torch.tensor([12.,34,25,11,67,32,29,30,99,55,23,44])

##获取张量前四个大的值及其所在位置
torch.topk(A,4)
# torch.return_types.topk(
# values=tensor([99., 67., 55., 44.]),
# indices=tensor([ 8,  4,  9, 11]))


##二维
B = A.reshape(3,4)
print("B:\n",B)
Btop2,Btop2_id = torch.topk(B,2,dim = 0)
print("B  每列 top2：\n",Btop2)
print("B  每列 top2 位置：\n",Btop2_id)
# B:
#  tensor([[12., 34., 25., 11.],
#         [67., 32., 29., 30.],
#         [99., 55., 23., 44.]])
# B  每列 top2：
#  tensor([[99., 55., 29., 44.],
#         [67., 34., 25., 30.]])
# B  每列 top2 位置：
#  tensor([[2, 2, 1, 2],
#         [1, 0, 0, 1]])

##获取张量第k小的数值和位置
torch.kthvalue(A,3)
# torch.return_types.kthvalue(
# values=tensor(23.),
# indices=tensor(10))

#二维 每一列的第k小数值及其位置
torch.kthvalue(B,3,dim =1)
# torch.return_types.kthvalue(
# values=tensor([25., 32., 55.]),
# indices=tensor([2, 1, 1]))

Bkth,Bkth_id = torch.kthvalue(B,3,dim=1,keepdim = True)
Bkth
# tensor([[25.],
#         [32.],
#         [55.]])

均值、求和、累加和、中位数、乘积、累乘积、标准差、

import torch
A= torch.tensor([12.,34,25,11,67,32,29,30,99,55,23,44])

B = A.reshape(3,4)
print("B:\n",B)
# B:
#  tensor([[12., 34., 25., 11.],
#         [67., 32., 29., 30.],
#         [99., 55., 23., 44.]])

##计算每一行的均值
print(torch.mean(B,dim = 1,keepdim=True))
# tensor([[20.5000],
#         [39.5000],
#         [55.2500]])

##计算每一列的均值
print(torch.mean(B,dim = 0,keepdim=True))
# tensor([[59.3333, 40.3333, 25.6667, 28.3333]])


##计算每一行的和
print(torch.sum(B,dim=1,keepdim = True))
# tensor([[ 82.],
#         [158.],
#         [221.]])

print(torch.sum(B,dim=0,keepdim = True))
# tensor([[178., 121.,  77.,  85.]])

##按照行计算累加和
print(torch.cumsum(B,dim=1))
# tensor([[ 12.,  46.,  71.,  82.],
#         [ 67.,  99., 128., 158.],
#         [ 99., 154., 177., 221.]])

##按照列计算累加和
print(torch.cumsum(B,dim=0))
# tensor([[ 12.,  34.,  25.,  11.],
#         [ 79.,  66.,  54.,  41.],
#         [178., 121.,  77.,  85.]])


##计算每一行的中位数
print(torch.median(B,dim=1,keepdim = True))
# values=tensor([[12.],
#         [30.],
#         [44.]]),
# indices=tensor([[0],
#         [3],
#         [3]]))

##计算每一列的中位数
print(torch.median(B,dim=0,keepdim = True))
# torch.return_types.median(
# values=tensor([[67., 34., 25., 30.]]),
# indices=tensor([[1, 0, 0, 1]]))


##按照行计算乘积
print(torch.prod(B,dim=1,keepdim = True))
# tensor([[ 112200.],
#         [1865280.],
#         [5510340.]])

##按照列计算乘积
print(torch.prod(B,dim=0,keepdim = True))
# tensor([[79596., 59840., 16675., 14520.]])


##按照行计算累乘积
print(torch.cumprod(B,dim = 1))
# tensor([[1.2000e+01, 4.0800e+02, 1.0200e+04, 1.1220e+05],
#         [6.7000e+01, 2.1440e+03, 6.2176e+04, 1.8653e+06],
#         [9.9000e+01, 5.4450e+03, 1.2524e+05, 5.5103e+06]])

##按照列计算累乘积
print(torch.cumprod(B,dim = 0))
# tensor([[1.2000e+01, 3.4000e+01, 2.5000e+01, 1.1000e+01],
#         [8.0400e+02, 1.0880e+03, 7.2500e+02, 3.3000e+02],
#         [7.9596e+04, 5.9840e+04, 1.6675e+04, 1.4520e+04]])



##标准差
torch.std(A)
# tensor(25.0108)
hhhhxxn
关注
  • 2
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
深度之眼Pytorch打卡（三）：Pytorch张量操作（包括torch.stack()理解、广播(broadcastable)的理解）
意疏的学习笔记
04-11 1262
前言
torch.allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False) → bool
wxyllyw的博客
10-30 2546
torch.allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False) → bool 在一定的误差允许内，判断两个值是否相等
PyTorch深度学习——张量及其运算
最新发布
just do it
04-05 997
最后一个和大小有关的函数是排序函数sort（默认是从小到大，如果需要从大到小排序，则需要设置参数 descending=True），同样是传入具体需要进行排序的维度，返回的是排序完的张量，记忆对应排序后的元素在原始张量上的位置，如果要知道原始张量还是那的元素沿着某个维度排第几位，只需要对应排序后的元素在原始张量上的位置进行再次排序，得到新位置的值即为原始张量沿着搞方向进行大小排序后的序号，和前面一样，关于排序和极值的函数，既可以是Pytorch的函数，也可以是张量的内置方法，两种方法的调用方法等价。
pytorch笔记：allclose，isclose，eq，equal
qq_40206371的博客
11-02 1301
是一个PyTorch函数，用于检查两个张量是否在某个容忍度范围内近似相等otherrtolatolequal_nan。
pytorch中张量的运算
m0_45827246的博客
01-01 2853
在深度学习中，经常需要对张量做四则、线性变换和激活等。 1. 单个张量的函数运算 t = torch.rand(2, 2) # 产生一个3x3的张量 print(t) print(t.sqrt()) # 张量的平方根，张量内部方法 print(torch.sqrt(t)) # 张量的平方根，函数形式 print(t.sqrt_()) # 平方根原地操作 print(torch.sum(t)) # 所有元素求和 print(torch.sum(t, 0)) # 第0维元素求和 print(torc
【NLP】Transformer—用注意力机制改进自然语言处理
sikh_0529的博客
09-24 9766
在上一章中，我们通过情感分析项目了解了() 及其在(然而，最近出现了一种新的架构，该架构已被证明优于多个 NLP 任务中基于 RNN 的() 模型。这就是所谓的架构。变形金刚已经彻底改变了自然语言处理，并处于许多令人印象深刻的应用程序的前沿，包括自动语言翻译 () 和建模基础蛋白质序列 () 的特性来创建帮助人们编写代码的 AI (）。在本章中，您将了解注意力和自注意力的基本机制，并了解它们是如何在原始转换器架构中使用的。
pytorch张量创建详细讲解
08-02
Jupyter文件，适用初学者，附带注释
创建pytorch张量
12-21
1、numpy->tensor 注： tensor()参数为具体的数据， Tensor() 和 FloatTensor()参数可以为数据也可以为维度信息，但是一般不用他来放数据 a = torch.Tensor(2, 3) print(a) a = torch.FloatTensor(2, 3) ...
PyTorch张量与操作1
08-03
下面我们将深入探讨PyTorch张量的创建、操作以及与Numpy数组的转换。 首先，我们来看如何创建PyTorch张量： 1. `torch.empty()`：这个函数用于创建一个未初始化的张量，即其元素值随机分布，通常不建议用于数值...
pytorch张量数据类型
02-21
pytorch张量数据类型
pytorch张量创建与操作
01-20
张量创建 1. 直接创建 1.1 torch.tensor() 1.2 torch.from_numpy(ndarray) #从numpy创建tensor， 与原ndarray共享内存 2. 通过数值创建 2.1 torch.zeros() torch.zeros_like() torch.ones() torch.ones_like() ...
【PyTorch教程】03-张量运算详细总结
Sihang_Xie的博客
07-06 2597
本篇教程介绍了PyTorch张量运算的主要操作。包括张量移到GPU进行运算、张量的切片和索引、张量的拼接、张量的转置、张量的点乘和叉乘以及自动赋值运算。相信读完本篇博文，你会得到答案。
pytorch元素相乘_Pytorch深度学习入门--2.Tensor数学操作及线性代数运算
weixin_39600704的博客
12-22 769
1 常用的数学操作在pytorch官方文档上，Tensor的数学操作方法有90多种，下图给了经常使用的25种数学操作方法（除线性代数运算外，线性运算下面会介绍）方法 说明 add() Tensor中每个元素同加一个标量，或与另一个Tensor逐元素相加 mul() ...
pytorch如何计算平方_[Pytorch]Pytorch中tensor常用语法
weixin_34609222的博客
02-11 9579
上次我总结了在PyTorch中建立随机数Tensor的多种方法的区别。这次我把常用的Tensor的数学运算总结到这里，以防自己在使用PyTorch做实验时，忘记这些方法应该传什么参数。总结的方法包括：Tensor求和以及按索引求和：torch.sum() torch.Tensor.indexadd()Tensor元素乘积：torch.prod(input)对Tensor求均值、方差、极值：...
pytorch张量运算
guohui0412的博客
10-13 275
pytorch张量运算 张量的简介生成不同数据类型的张量list和numpy.ndarray转换为TensorTensor与Numpy Array之间的转换Tensor的基本类型转换（float转double，转byte等）torch.arange()、torch.range()、torch.linspace的区别：张量的重排...
pytorch单个张量的的函数运算
weixin_43220532的博客
04-17 213
pytorch单个张量的的函数运算操作既可以由张量自带的方法实现，比如下面的a.sqrt()，也可以由torch包中的一些函数实现： import torch a = torch.rand(3, 4) # 产生一个3*4的张量 print(a) print(a.sqrt()) # 张量的平方根，张量的内部方法,a不会随之改变 print(torch.sqrt(a)) # 张量的函数形式，张量的内部方法,a不会随之改变 print(a.sqrt_()) # 平方根原地操作，a会随之改变 pri
torch 指数
Python领域优质萌新创作者
06-04 928
函数计算张量的指数。该函数将输入张量的每个元素都取指数。中进行指数和对数运算的灵活性和方便性，可以根据需要选择适合的函数来处理数据。如果输入张量的类型为整型，需要先将其转换为浮点型再进行指数运算。：计算输入张量的指数值减去1，即e的幂次方减去1。函数接受并处理浮点型张量，因此输入张量的类型应为。计算了每个元素的指数值，并返回一个新的张量。：计算输入张量的指数值，即e的幂次方。：计算输入张量的以10为底的对数。：计算输入张量的以2为底的对数。，其中包含了对应的指数值。：计算输入张量的自然对数。
[TensorFlow系列-10]：TensorFlow基础 - 张量元素的比较运算
热门推荐
文火冰糖（王文兵）的博客
08-12 1万+
作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing 本文网址： 目录 第1章 Tensor运算概述 1.1 概述 1.3 “in place“运算: 不支持 1.4Tensor的广播机制: 不同维度的tensor实例运算 1.5 环境准备 1.6 比较运算概述 第2章 常规值的比较示例 2.1 比较两个tensor是否完全相同：不支持 2.2 比较两个tensor的每个元素是否相等关系：tf.math.equal(x,y) ...
一文读懂PyTorch张量基础（附代码）
数据派THU
06-12 9624
作者：Matthew Mayo, KDnuggets翻译：和中华校对：丁楠雅本文约1000字，建议阅读5分钟。本文介绍了PyTorch Tensor最基础的知识以及如何跟...
pytorch 张量
07-28
PyTorch张量是PyTorch框架中的核心数据结构之一。它类似于NumPy的多维数组，但提供了GPU加速和自动求导等功能。 在PyTorch中，张量可以是标量（0维张量）、向量（1维张量）、矩阵（2维张量）或更高维的数组。可以使用torch.Tensor类创建张量对象。 以下是一个创建和操作PyTorch张量的示例： ```python import torch # 创建一个空的3x3浮点型张量 x = torch.empty(3, 3) print(x) # 创建一个随机初始化的3x3浮点型张量 y = torch.rand(3, 3) print(y) # 创建一个全零的整型张量 z = torch.zeros(2, 2, dtype=torch.int) print(z) # 使用数据直接创建张量 data = [1, 2, 3, 4] a = torch.tensor(data) print(a) # 张量的形状 print(a.shape) # 张量的大小 print(a.size()) # 张量的运算 b = torch.tensor([5, 6, 7, 8]) c = a + b print(c) ``` 以上代码演示了创建、形状、大小和运算等基本操作。PyTorch还提供了丰富的张量操作和数学函数，可以进行矩阵乘法、转置、索引、切片等操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值