聊一聊pytorch中的张量基本方法

简介: 聊一聊pytorch中的张量基本方法

张量


四种初始化方法


1.直接生成,原始结构类型决定张量类型

import torch
data = [[1,2],
       [3,4]]
x_data = torch.tensor(data)
>>>x_data
tensor([[1, 2],
        [3, 4]])

2.通过numpy转化生成张量(可以互相转化)

import numpy as np
np_array = np.array(data)
x_np = torch.from_numpy(np_array)
#x_np
>>>x_np
tensor([[1, 2],
        [3, 4]], dtype=torch.int32)

3.通过已有张量来生成新的张量

(同时新的张量将会继承已有张量的数据属性,包括结构、类型,也可以指定新的数据类型)

#torch.ones_like函数、torch.zeros_like函数、rand_like函数的基本功能是
#根据给定张量,生成与其形状相同的全1张量或全0张量或随机张量
>>>x_ones = torch.ones_like(x_data)
>>>x_ones
tensor([[1, 1],
        [1, 1]])
>>>x_rand = torch.rand_like(x_data,dtype = torch.float)
>>>x_rand
tensor([[0.5700, 0.4488],
        [0.3124, 0.0294]])


4.通过指定数据维度(shape)来生成张量

shape = (2,3)
one_tensor = torch.ones(shape)
one_tensor
'''
tensor([[1., 1., 1.],
        [1., 1., 1.]])
'''


张量的属性和运算


张量可以查询张量的维度、数据类型和存储设备(CPU或GPU)

tensor_sa = torch.rand(3,4)
print(tensor_sa)
print(tensor_sa.shape)
print(tensor_sa.dtype)
print(tensor_sa.device)
'''
tensor([[0.8177, 0.5182, 0.9222, 0.5564],
        [0.3470, 0.2929, 0.6438, 0.8626],
        [0.4011, 0.6267, 0.6672, 0.6296]])
torch.Size([3, 4])
torch.float32
cpu
'''


张量运算

常用的操作有转置、索引、切片、数学运算、线性代数、随机取样等


加减乘除
#加减乘除
a + b = torch.add(a, b)
a - b = torch.sub(a, b)
a * b = torch.mul(a, b)
a / b = torch.div(a, b)
#实操
import torch
a = torch.rand(3, 4)
b = torch.rand(4)
a
# 输出:
    tensor([[0.6232, 0.5066, 0.8479, 0.6049],
            [0.3548, 0.4675, 0.7123, 0.5700],
            [0.8737, 0.5115, 0.2106, 0.5849]])
b
# 输出:
    tensor([0.3309, 0.3712, 0.0982, 0.2331])
# 相加
# b会被广播 变成维度相同的进行加减乘除
a + b
# 输出:
    tensor([[0.9541, 0.8778, 0.9461, 0.8380],
            [0.6857, 0.8387, 0.8105, 0.8030],
            [1.2046, 0.8827, 0.3088, 0.8179]])   
# 等价于上面相加
torch.add(a, b)
# 输出:
    tensor([[0.9541, 0.8778, 0.9461, 0.8380],
            [0.6857, 0.8387, 0.8105, 0.8030],
            [1.2046, 0.8827, 0.3088, 0.8179]])  
# 比较两个是否相等
torch.all(torch.eq(a + b, torch.add(a, b)))
# 输出:
    tensor(True)    
矩阵相乘
torch.mm(a, b) # 此方法只适用于2维
torch.matmul(a, b)
a @ b = torch.matmul(a, b) # 推荐使用此方法
#实操
a = torch.full((2, 2), 3)
a
# 输出
    tensor([[3., 3.],
            [3., 3.]])
b = torch.ones(2, 2)
b
# 输出
    tensor([[1., 1.],
            [1., 1.]])
torch.mm(a, b)
# 输出
    tensor([[6., 6.],
            [6., 6.]])
torch.matmul(a, b)
# 输出
    tensor([[6., 6.],
            [6., 6.]])
a @ b
# 输出
    tensor([[6., 6.],
            [6., 6.]])    


幂次计算
pow, sqrt, rsqrt
a = torch.full([2, 2], 3)
a
# 输出
    tensor([[3., 3.],
            [3., 3.]])
a.pow(2)
# 输出
    tensor([[9., 9.],
            [9., 9.]])    
aa = a ** 2
aa
# 输出
    tensor([[9., 9.],
            [9., 9.]]) 
# 平方根
aa.sqrt()
# 输出
    tensor([[3., 3.],
            [3., 3.]])
# 平方根    
aa ** (0.5)
# 输出
    tensor([[3., 3.],
            [3., 3.]])    
# 平方根    
aa.pow(0.5)
# 输出
    tensor([[3., 3.],
            [3., 3.]])    
# 平方根的倒数
aa.rsqrt()
# 输出
    tensor([[0.3333, 0.3333],
            [0.3333, 0.3333]])        
tensor([[3., 3.],
        [3., 3.]])


近似值
a.floor() # 向下取整:floor,地板
a.ceil() # 向上取整:ceil,天花板
a.trunc() # 保留整数部分:truncate,截断
a.frac() # 保留小数部分:fraction,小数
a.round() # 四舍五入:round,大约


限幅
a.max() # 最大值
a.min() # 最小值
a.median() # 中位数
a.clamp(10) # 将最小值限定为10
a.clamp(0, 10) # 将数据限定在[0, 10],两边都是闭区间
#实操
a
'''
tensor([[0.1042, 0.5222, 0.8518, 0.5040],
        [0.4868, 0.9410, 0.1554, 0.2218],
        [0.7903, 0.5346, 0.5185, 0.0802]])
'''
a.max()
'''
tensor(0.9410)
'''
a.min()
'''
tensor(0.0802)
'''
a.clamp(0.51)
'''
tensor([[0.5100, 0.5222, 0.8518, 0.5100],
        [0.5100, 0.9410, 0.5100, 0.5100],
        [0.7903, 0.5346, 0.5185, 0.5100]])
'''
a.clamp(0.2,0.51)
'''
tensor([[0.2000, 0.5100, 0.5100, 0.5040],
        [0.4868, 0.5100, 0.2000, 0.2218],
        [0.5100, 0.5100, 0.5100, 0.2000]])
'''


张量方法


torch.full() torch.full_like()
x = torch.full((3,2),fill_value = 5,dtype = torch.long)
'''
tensor([[5, 5],
        [5, 5],
        [5, 5]])
'''
y = torch.full_like(x,1.7,dtype = torch.float)
y
'''
tensor([[1.7000, 1.7000],
        [1.7000, 1.7000],
        [1.7000, 1.7000]])
'''


索引和切片
ten = torch.ones(4,4)
ten[:,1] = 0
ten
'''
tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])
'''


拼接 torch.cat torch.stack

torch.cat 仅仅是张量的连接,不会增加维度

20210429110113179.png

2021042911053392.png

torch.cat(tensors, dim = 0, out = None)
#除了dim那个维度,其余维度待拼接尺寸要相同
#不会对原张量产生影响

torch.stack 是堆叠,会增加维度,可以参考下面栗子理解一下

torch.stack((x1,x2),0)
'''
tensor([[[0.0894, 0.1871, 0.6987],
         [0.9175, 0.0312, 0.4474]],
        [[0.1643, 0.6791, 0.7948],
         [0.1119, 0.5024, 0.1492]]])
'''
torch.stack((x1,x2),1)
'''
tensor([[[0.0894, 0.1871, 0.6987],
         [0.1643, 0.6791, 0.7948]],
        [[0.9175, 0.0312, 0.4474],
         [0.1119, 0.5024, 0.1492]]])
'''
torch.stack((x1,x2),2)
'''
tensor([[[0.0894, 0.1643],
         [0.1871, 0.6791],
         [0.6987, 0.7948]],
        [[0.9175, 0.1119],
         [0.0312, 0.5024],
         [0.4474, 0.1492]]])
'''


Tensor和Numpy转化

张量与Numpy array数据组在cpu上可以共用一块内存,所以改变一个另一个也会发生变化。


1.Tensor -> Numpy array
(tensor.add_() 自赋值计算)

20210429111342491.png

2.Numpy array -> Tensor

20210509164231456.png

相关文章
|
2月前
|
机器学习/深度学习 存储 PyTorch
Pytorch中in-place操作相关错误解析及detach()方法说明
Pytorch中in-place操作相关错误解析及detach()方法说明
156 0
|
12天前
|
算法 PyTorch 算法框架/工具
Pytorch - 张量转换拼接
使用 Tensor.numpy 函数可以将张量转换为 ndarray 数组,但是共享内存,可以使用 copy 函数避免共享。
|
12天前
|
存储 机器学习/深度学习 PyTorch
Pytorch-张量形状操作
PyTorch中,张量形状操作至关重要,如reshape用于改变维度而不变元素,transpose/permute用于维度交换,view改形状需内存连续,squeeze移除单维度,unsqueeze添加维度。这些函数帮助数据适应神经网络层间的转换。例如,reshape能调整数据适配层的输入,transpose用于矩阵转置或多维排列,而squeeze和unsqueeze则用于处理单维度。理解并熟练运用这些工具是深度学习中必要的技能。
|
12天前
|
机器学习/深度学习 人工智能 PyTorch
PyTorch-张量
PyTorch 是Facebook AI团队开发的深度学习框架,其核心是张量,它是同类型数据的多维数组。张量可以通过`torch.tensor()`、`torch.Tensor()`、指定类型如`IntTensor`等创建。张量操作包括线性(`torch.arange`, `torch.linspace`)、随机(`torch.randn`, `torch.manual_seed`)和全0/1张量(`torch.zeros`, `torch.ones`)。张量间可进行阿达玛积(逐元素相乘),类型转换用`type()`或`double()`。
|
12天前
|
机器学习/深度学习 PyTorch 算法框架/工具
Pytorch-张量基础操作
张量是一个多维数组,它是标量、向量和矩阵概念的推广。在深度学习中,张量被广泛用于表示数据和模型参数。
|
13天前
|
并行计算 PyTorch 算法框架/工具
pytorch张量的创建
• 张量(Tensors)类似于NumPy的ndarrays ,但张量可以在GPU上进行计算。从本质上来说,PyTorch是一个处理张量的库。一个张量是一个数字、向量、矩阵或任何n维数组。
|
21天前
|
机器学习/深度学习 PyTorch 算法框架/工具
【从零开始学习深度学习】18. Pytorch中自定义层的几种方法:nn.Module、ParameterList和ParameterDict
【从零开始学习深度学习】18. Pytorch中自定义层的几种方法:nn.Module、ParameterList和ParameterDict
|
21天前
|
机器学习/深度学习 算法 PyTorch
【从零开始学习深度学习】45. Pytorch迁移学习微调方法实战:使用微调技术进行2分类图片热狗识别模型训练【含源码与数据集】
【从零开始学习深度学习】45. Pytorch迁移学习微调方法实战:使用微调技术进行2分类图片热狗识别模型训练【含源码与数据集】
|
21天前
|
机器学习/深度学习 PyTorch 算法框架/工具
【从零开始学习深度学习】17. Pytorch中模型参数的访问、初始化和共享方法
【从零开始学习深度学习】17. Pytorch中模型参数的访问、初始化和共享方法
|
2月前
|
机器学习/深度学习 PyTorch 算法框架/工具
使用FP8加速PyTorch训练的两种方法总结
在PyTorch中,FP8数据类型用于高效训练和推理,旨在减少内存占用和加快计算速度。虽然官方尚未全面支持,但在2.2版本中引入了`torch.float8_e4m3fn`和`torch.float8_e5m2`。文章通过示例展示了如何利用FP8优化Vision Transformer模型,使用Transformer Engine库提升性能,并探讨了PyTorch原生FP8支持的初步使用方法。实验表明,结合TE和FP8,训练速度可提升3倍,性能有显著增强,特别是在NVIDIA GPU上。然而,PyTorch的FP8支持仍处于试验阶段,可能带来不稳定性。
66 0