1深度学习Pytorch-pytorch、tensor的创建、属性、设备和类型转换、数据转换、常见操作（获取元素、元素运算、形状改变、相乘、广播）

2202_756749692025-08-07 7:01

文章目录

    • PyTorch
    • Tensor
      • [1 Tensor 的创建](#1 Tensor 的创建)
        • 1.torch.tensor
        • 2.torch.Tensor
        • [3. 线性张量](#3. 线性张量)
        • [4. 随机张量](#4. 随机张量)
        • [5. 特定数值的张量](#5. 特定数值的张量)
      • [2 Tensor 常见属性](#2 Tensor 常见属性)
      • [4 数据转换（浅拷贝与深拷贝）](#4 数据转换（浅拷贝与深拷贝）)
      • [5. Tensor常见操作](#5. Tensor常见操作)
        • [5.1 获取元素值](#5.1 获取元素值)
        • [5.2 元素值运算](#5.2 元素值运算)
        • [5.3 形状操作](#5.3 形状操作)
          • [5.3.1 改变形状（reshape /view）](#5.3.1 改变形状（reshape /view）)
          • [5.3.2 维度增减（unsqueeze /squeeze）](#5.3.2 维度增减（unsqueeze /squeeze）)
          • [5.3.3 维度交换（transpose /permute）](#5.3.3 维度交换（transpose /permute）)
        • [5.4 阿达玛积](#5.4 阿达玛积)
        • [5.5 Tensor相乘](#5.5 Tensor相乘)
      • [6 广播机制（Broadcasting）](#6 广播机制（Broadcasting）)

PyTorch

PyTorch 是由 Meta（原 Facebook）开发的开源深度学习框架，于 2016 年发布，以灵活性、动态计算图和易用性为核心特点，广泛应用于学术研究和工业界。

其核心优势包括：

  • 动态计算图：计算过程实时构建，支持在运行中修改网络结构，便于调试和灵活实验
  • 自动求导机制：自动计算张量操作的梯度，简化反向传播实现
  • GPU 加速：无缝支持 CUDA 加速，大幅提升大规模张量运算效率
  • 丰富生态：配套 TorchVision（计算机视觉）、TorchText（自然语言处理）等工具库
  • 良好兼容性：支持模型导出为 ONNX 格式，便于跨框架部署

PyTorch 的核心数据结构是张量（Tensor），所有神经网络操作都围绕张量展开。

Tensor

  • 核心数据结构： torch.Tensor 是 PyTorch 中最基本、最重要的数据结构，类似于 NumPy 的 ndarray，但拥有额外的特性使其适用于深度学习。
  • 本质： 一个多维数组（张量）。标量是 0 维张量，向量是 1 维张量，矩阵是 2 维张量，依此类推。
  • 关键特性：
    • GPU 加速： 可以轻松地将 Tensor 移动到 GPU 上进行高速并行计算。
    • 自动微分 (Autograd)： Tensor 可以跟踪在其上执行的操作，以自动计算梯度（导数），这是训练神经网络的核心（反向传播）。
    • 丰富的操作： 提供了大量用于数学运算、线性代数、随机采样等的函数。

1 Tensor 的创建

有多种方式创建 Tensor：

1.torch.tensor

从 Python 列表或序列创建：

python 复制代码 
import torch
# 创建标量 (0维)
scalar = torch.tensor(3.14)
# 创建向量 (1维)
vector = torch.tensor([1, 2, 3, 4])
# 创建矩阵 (2维)
matrix = torch.tensor([[1., 2.], [3., 4.]])
# 创建3维张量
tensor_3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
2.torch.Tensor
py 复制代码 
# 1. 根据形状创建张量
tensor1 = torch.Tensor(2, 3)
print(tensor1)
# 2. 也可以是具体的值
tensor2 = torch.Tensor([[1, 2, 3], [4, 5, 6]])
print(tensor2, tensor2.shape, tensor2.dtype)

tensor3 = torch.Tensor([10])
print(tensor3, tensor3.shape, tensor3.dtype)
    
# 指定tensor数据类型
tensor1 = torch.Tensor([1,2,3]).short()
print(tensor1)

tensor1 = torch.Tensor([1,2,3]).int()
print(tensor1)
3. 线性张量

使用 torch.arange() / torch.linspace()： 创建线性序列

  • torch.arange(start=0, end, step=1)： 类似 Python range，创建从 start 到 end（不包括 end），步长为 step 的 1 维 Tensor。
  • torch.linspace(start, end, steps)： 创建从 start 到 end（包括 end）的等间隔 steps 个点组成的 1 维 Tensor。
py 复制代码 
# 类似range，生成[start, end)的整数序列
t_arange = torch.arange(0, 10, step=2)  # 结果：[0, 2, 4, 6, 8]

# 生成均匀分布的线性序列（包含end）
t_linspace = torch.linspace(0, 1, steps=5)  # 结果：[0.0, 0.25, 0.5, 0.75, 1.0]
4. 随机张量

使用 torch.rand() / torch.randn() / torch.randint()： 创建随机初始化的 Tensor。

  • torch.rand(*size)： 从 [0, 1) 均匀分布中随机采样。
  • torch.randn(*size)： 从 标准正态分布（均值为0，方差为1） 中随机采样。
  • torch.randint(low, high, size)： 从 [low, high) 的整数均匀分布中随机采样。
py 复制代码 
# 均匀分布 [0,1)
t_rand = torch.rand(2, 3)  # 形状为(2,3)的随机张量

# 标准正态分布（均值0，方差1）
t_randn = torch.randn(3, 3)

# 随机整数 [low, high)
t_randint = torch.randint(low=0, high=10, size=(2, 2))  # 2x2的0-9随机整数

# 固定随机种子（保证结果可复现）
torch.manual_seed(42)
5. 特定数值的张量
py 复制代码 
t_zeros = torch.zeros((2, 3))  # 全零张量，形状(2,3)
t_ones = torch.ones((3, 3))   # 全一张量
t_full = torch.full((2, 2), 5)  # 填充指定值（5）
t_eye = torch.eye(3)  # 单位矩阵（对角线为1，其余为0）

2 Tensor 常见属性

1 属性
.shape 张量的形状（各维度大小） t = torch.rand(2, 3); print(t.shape) torch.Size([2, 3])
.size() 与 .shape 等价，返回形状元组 print(t.size(0)) 2（第 0 维大小）
.dtype 数据类型（如 float32、int64 等） print(t.dtype) torch.float32
.device 存储设备（CPU 或 GPU） print(t.device) cpu 或 cuda:0
.requires_grad 是否需要计算梯度（用于反向传播） t = torch.tensor(2.0, requires_grad=True); print(t.requires_grad) True
.grad 存储梯度值（需先调用 .backward()） t.backward(); print(t.grad) tensor(1.)（示例梯度值）
.is_cuda 是否在 GPU 上（布尔值） print(t.is_cuda) False（CPU 上）
.numel() 总元素数量（各维度大小乘积） print(t.numel()) 6（2×3 的张量）
2 设备切换

PyTorch 支持张量在 CPU 和 GPU 之间迁移，以利用 GPU 的并行计算能力加速深度学习任务。

复制代码 
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

方法 1：使用 .to(device)

py 复制代码 
# 创建一个 CPU 上的张量
t_cpu = torch.tensor([1, 2, 3])
print("原始设备:", t_cpu.device)  # cpu

# 迁移到 GPU（若可用）
t_gpu = t_cpu.to(device)
print("迁移后设备:", t_gpu.device)  # cuda:0（若有GPU）

# 从 GPU 迁回 CPU
t_cpu2 = t_gpu.to("cpu")
print(t_cpu2.device)  # cpu

方法 2：使用 .cuda() 和 .cpu()

py 复制代码 
    t2 = torch.tensor([1,2,3])
    t2 = t2.cuda()
    print(t2)

    t3 = t2.cpu()
    print(t3)
3 类型转换
torch.Tensor.to(dtype)

通用方法，通过 dtype 参数指定目标类型，适用于所有转换场景：

python 复制代码 
import torch

# 原始张量（int64类型）
t = torch.tensor([1, 2, 3], dtype=torch.int64)
print("原始类型:", t.dtype)  # torch.int64

# 转换为 float32（默认浮点类型）
t_float32 = t.to(torch.float32)
print("转换为float32:", t_float32.dtype)  # torch.float32

# 转换为 int32
t_int32 = t.to(torch.int32)
print("转换为int32:", t_int32.dtype)  # torch.int32

# 转换为 bool 类型（非0值为True）
t_bool = t.to(torch.bool)
print("转换为bool:", t_bool.dtype, t_bool)  # torch.bool tensor([True, True, True])
类型专用方法

PyTorch 为常用类型提供了专用方法，更简洁直观：

python 复制代码 
t = torch.tensor([1, 2, 3], dtype=torch.int32)

t_float = t.float()       # 等价于 to(torch.float32)
t_double = t.double()     # 等价于 to(torch.float64)
t_long = t.long()         # 等价于 to(torch.int64)
t_int = t.int()           # 等价于 to(torch.int32)
t_bool = t.bool()         # 等价于 to(torch.bool)
创建张量时直接指定类型

通过 dtype 参数在创建张量时就确定类型，避免后续转换：

python 复制代码 
# 直接创建 float16 类型张量
t_half = torch.tensor([1.5, 2.5], dtype=torch.float16)
print(t_half.dtype)  # torch.float16

# 直接创建 uint8 类型张量（图像数据常用）
t_uint8 = torch.tensor([0, 128, 255], dtype=torch.uint8)
print(t_uint8.dtype)  # torch.uint8
与 NumPy 数组的类型互转

PyTorch 张量与 NumPy 数组转换时，类型会自动对应，也可显式指定：

python 复制代码 
import numpy as np

# NumPy 数组（float64类型）
np_arr = np.array([1.2, 3.4], dtype=np.float64)

# 转换为 PyTorch 张量（默认对应 float64）
t = torch.from_numpy(np_arr)
print(t.dtype)  # torch.float64

# 转换时显式指定类型
t = torch.from_numpy(np_arr).to(torch.float32)
print(t.dtype)  # torch.float32

# 张量转 NumPy 数组（保留类型）
np_arr2 = t.numpy()
print(np_arr2.dtype)  # float32

4 数据转换（浅拷贝与深拷贝）

在 PyTorch 中理解数据转换（尤其是涉及内存共享）非常重要，因为它直接影响内存使用和计算结果。

  • 浅拷贝 (Shallow Copy)： 创建一个新对象，但新对象的内容是对原对象内容的引用。修改新对象的内容可能会改变原对象的内容（因为它们共享底层数据）。内存效率高。
  • 深拷贝 (Deep Copy)： 创建一个新对象，并且递归地复制原对象及其包含的所有对象。新对象与原对象完全独立，修改其中一个不会影响另一个。内存开销更大。
张量转Numpy

numpy():张量转numpy数组，浅拷贝，修改numpy的元素会修改张量元素

numpy().copy():深拷贝，复制一个副本，修改副本不会影响源张量元素

py 复制代码 
    t = torch.tensor([1,2,3])
    print(t)	#tensor([1, 2, 3])

    # numpy():张量转numpy数组，浅拷贝，修改numpy的元素会修改张量元素
    a = t.numpy()
    a[0]=100
    print(a)	#[100   2   3]
    print(t)	#tensor([100,   2,   3])

    b = t.numpy().copy()
    # numpy().copy():深拷贝，复制一个副本，修改副本不会影响源张量元素
    b[0]=200
    print(b)	#[200   2   3]
    print(t)	#tensor([100,   2,   3])
Numpy转张量

torch.from_numpy():numpy数组转张量，浅拷贝，修改张量元素会修改numpy的元素

torch.tensor():numpy数组转张量，深拷贝，会创建新的存储空间，修改副本不会影响源numpy元素

py 复制代码 
    a = np.array([1,2,3])
    print(a)
    # torch.from_numpy():numpy数组转张量，浅拷贝，修改张量元素会修改numpy的元素
    t = torch.from_numpy(a)
    print(t)

    t[0] = 100
    print(t,a)

    # torch.tensor():numpy数组转张量，深拷贝，复制一个副本，修改副本不会影响源numpy元素
    t1 = torch.tensor(a)
    t1[0]=999
    print(a)

5. Tensor常见操作

5.1 获取元素值

item()方法：单个元素的数组获取元素值，维度不影响

  • 和Tensor的维度没有关系，都可以取出来
  • 如果有多个元素则报错；
py 复制代码 
    t = torch.tensor(10)
    print((t.item()))

    t1 = torch.tensor([[10]])
    print(t1.item())
5.2 元素值运算

常见的加减乘除次方取反开方等各种操作，带有_的方法则会替换原始值。

python 复制代码 
import torch

def test001():
    # 生成范围 [0, 10) 的 2x3 随机整数张量
    data = torch.randint(0, 10, (2, 3))
    print(data)
    # 元素级别的加减乘除：不修改原始值
    print(data.add(1))
    print(data.sub(1))
    print(data.mul(2))
    print(data.div(3))
    print(data.pow(2))

    # 元素级别的加减乘除：修改原始值
    data = data.float()
    data.add_(1)
    data.sub_(1)
    data.mul_(2)
    data.div_(3.0)
    data.pow_(2)
    print(data)


if __name__ == "__main__":
    test001()
5.3 形状操作

调整 Tensor 的维度和形状是适配神经网络输入输出的关键操作。

5.3.1 改变形状（reshape /view）
  • view(new_shape)：修改数组形状，不改变内存存储顺序，效率较高，
    • 前提是tensor在内存中是连续 的，否则需先用contiguous()转换；
    • 如果进行转置等操作导致数据不连续，此时使用view()方法会报错
    • 支持 -1 自动计算维度，总元素数必须与原张量一致
  • reshape(new_shape)：功能类似 NumPy 的reshape，会自动处理非连续情况（内部可能调用view或复制数据）
python 复制代码 
x = torch.arange(12)  # 形状：(12,)

# reshape：灵活改变形状（推荐，自动处理非连续内存）
x1 = x.reshape(3, 4)  # 3行4列 → (3,4)
x2 = x.reshape(2, 2, 3)  # 3维 → (2,2,3)

# view：类似reshape，但要求Tensor内存连续（不连续时会报错）
x3 = x.view(4, 3)  # 4行3列 → (4,3)
5.3.2 维度增减（unsqueeze /squeeze）

  • unsqueeze：用于在指定位置插入一个大小为 1 的新维度。

  • squeeze：用于移除所有大小为 1 的维度，或者移除指定维度的大小为 1 的维度;若删除的维度数不为1，则不做任何操作，也不报错

python 复制代码 
x = torch.tensor([1, 2, 3])  # 形状：(3,)

# unsqueeze：在指定位置增加一个维度（维度大小为1）
x_unsq0 = x.unsqueeze(0)  # 形状：(1,3)（在第0维增加）
x_unsq1 = x.unsqueeze(1)  # 形状：(3,1)（在第1维增加）

# squeeze：删除大小为1的维度（默认删除所有）
x_sq0 = x_unsq0.squeeze()  # 形状：(3,)（删除第0维）
x_sq1 = x_unsq1.squeeze(1)  # 形状：(3,)（指定删除第1维）
5.3.3 维度交换（transpose /permute）

transpose: 用于交换张量的两个维度,返回新张量，原张量不变

permute:重新排列张量的维度,不改变张量的数据，只改变维度的顺序

python 复制代码 
x = torch.randn(2, 3, 4)  # 形状：(2,3,4)（假设为[batch, height, width]）

# transpose：交换两个维度
x_trans = x.transpose(1, 2)  # 交换1和2维 → 形状：(2,4,3)

# permute：重排所有维度（更灵活）
x_perm = x.permute(2, 0, 1)  # 维度顺序变为2→0→1 → 形状：(4,2,3)
5.4 阿达玛积

对两个形状相同的 Tensor，对应位置的元素相乘，结果形状与输入相同。

实现方式：

  • 运算符：*
  • 函数：torch.mul(a, b)
  • 方法：a.mul(b)
py 复制代码 
'''# 阿达码积:
前提：两个矩阵形状相同；
两个矩阵相同位置元素相乘：Cij = Mij * Nij
运算：mul   *
'''
    t = torch.tensor([[1,2,3],[3,4,5]])
    t1 = torch.tensor([[5,6,6],[7,8,9]])
    print(t.mul(t1))
    print(t*t1)
    '''
    tensor([[ 5, 12, 18],
        [21, 32, 45]])
	tensor([[ 5, 12, 18],
        [21, 32, 45]])	
    '''
5.5 Tensor相乘

要求前一个矩阵的列数等于后一个矩阵的行数。

实现方式：

  • 运算符：@
  • 函数：torch.matmul(a, b)
  • 方法：a.matmul(b)
py 复制代码 
'''
矩阵运算：(M X N) x (N X M)
第一个矩阵的第一行于第二个矩阵的第一列元素分别相乘之和...
运算符号：matmul  @
'''
    t = torch.tensor([[1,2,3],
                      [3,4,5]])
    t1 = torch.tensor([[5,6],
                       [7,8],
                       [9,10]])
    print(t.matmul(t1))
    print(t@t1)
    
    '''
    tensor([[ 46,  52],
        [ 88, 100]])
	tensor([[ 46,  52],
        [ 88, 100]])
    '''

6 广播机制（Broadcasting）

当两个 Tensor 形状不同时，PyTorch 会自动扩展它们的维度以匹配，便于元素级运算（类似 NumPy 的广播）。

广播规则：

  1. 若维度数量不同，在形状较短的 Tensor 前补 1，直到维度数量一致。
  2. 对于每个维度，若两个 Tensor 的大小相同，或其中一个为 1，则可广播（扩展为较大的大小）。
python 复制代码 
a = torch.tensor([[1, 2, 3], [4, 5, 6]])  # 形状：(2,3)
b = torch.tensor([10, 20, 30])           # 形状：(3,)

# 广播后：
# a保持(2,3)，b扩展为(2,3) → [[10,20,30], [10,20,30]]
c = a + b  # 结果：[[11,22,33], [14,25,36]]

# 另一个例子：(3,1) 与 (1,4) 广播为 (3,4)
d = torch.tensor([[1], [2], [3]])  # (3,1)
e = torch.tensor([[10, 20, 30, 40]])  # (1,4)
f = d + e  
# 结果：3x4矩阵 → [[11,21,31,41], [12,22,32,42],[13,23,33,43]]
相关推荐
yzx991013几秒前
探索机器学习在医疗领域的应用与挑战
人工智能·爬虫·机器学习
max5006001 分钟前
基于最大似然估计的卡尔曼滤波与自适应模糊PID控制的单片机实现
数据库·python·单片机·深度学习·mongodb·机器学习·transformer
虹科电子科技8 分钟前
安宝特方案丨工业AR+AI质检方案：致力于提升检测精度与流程效率
人工智能·ar·工业ai质检
沉默媛13 分钟前
块三角掩码（Block-Triangular Masking）
人工智能·深度学习·公式解析
Godspeed Zhao19 分钟前
自动驾驶中的传感器技术24——Camera（15）
人工智能·机器学习·自动驾驶·camera·摄像头
湫兮之风44 分钟前
Opencv: 不同函数所支持的Mat类型汇总
人工智能·opencv·计算机视觉
plusplus1681 小时前
深度解析：AI如何重塑供应链？从被动响应到预测性防御的三大核心实践
人工智能
从零开始学习人工智能1 小时前
从Token到序列：阿里GSPO算法如何让大模型训练更稳、更强？
人工智能·算法·机器学习
阿川！1 小时前
AI创作--用AI写小说实例
人工智能
m0_642330471 小时前
【人工智能-18】机器学习：决策树、随机森林
人工智能·决策树·机器学习
热门推荐
01Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code02全球最强模型Grok4，国内已可免费使用！（附教程）03UV安装并设置国内源04KGG转MP3工具|非KGM文件|解密音频05腾讯还是太全面了，限时免费！超全CodeBuddy IDE保姆级教程！（附案例）06如何在 Cursor 中继续使用 Claude07Cursor 终端“卡死/无响应”问题的解法08ChatGPT 5发布日期揭秘：2025年8月上线，多模态推理能力全面升级09NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南10VMware Workstation Pro虚拟机的下载和安装图文保姆级教程(附下载链接)