AI学习(3): PyTorch-初识张量

1.介绍

PyTorch中的张量（tensor）是其核心数据结构，表示任意维度的数组。张量可以用于存储和处理数据，是PyTorch中的基本构建模块。

在PyTorch中，张量是torch.Tensor类的实例，它提供了丰富的方法和功能，用于进行数值计算和深度学习模型的构建与训练。

1.1 创建函数

在PyTorch中，有多种方法可以创建张量，如:torch.tensor()、torch.as_tensor()、torch.from_numpy()等。这些方法在处理不同类型的数据和内存共享方面有所不同，开发者可以根据具体需求选择合适的方法来创建张量;

torch.tensor() 是 PyTorch 中常用于创建张量的函数之一。该函数可以从其他 Python 可迭代对象（如列表、元组）或 NumPy 数组中创建张量。下面是 torch.tensor() 函数的主要参数和它们的含义：

torch.tensor(data, dtype=None, device=None, requires_grad=False)

参数说明：

data (必填): 要转换为张量的数据。可以是 Python 列表( list)、元组( tuple)、 NumPy 数组等可迭代对象。
dtype (可选): 指定张量的数据类型。如果不提供， PyTorch 将尝试推断数据类型。
device (可选): 指定张量存储的设备，可以是 CPU 或 GPU。如果不提供，将使用默认设备。
requires_grad (可选): 是否启用自动求导机制，以便追踪对张量的操作并计算梯度，默认 False。

@注意:使用as_tensor()创建张量，将共享底层数据，对张量的修改会影响原始数据。

1.2 重要属性

张量(tensor)有很多重要的属性。以下是一些常用的 torch.Tensor 属性：

import numpy as np
import torch

if __name__ == "__main__":
    # 张量创建
    # 从numpy中创建张量
    numpyArray = np.array([
        [1, 2, 3],
        [4, 5, 6]
    ])
    numpyTensor = torch.tensor(numpyArray)
    print("numpyTensor: ", numpyTensor)
    print("形状: ", numpyTensor.shape)
    print("数据类型: ", numpyTensor.dtype)
    print("放置设备(GPU|CPU): ", numpyTensor.device)
    print("自动求导属性: ", numpyTensor.requires_grad)
    print("梯度信息: ", numpyTensor.grad)
    print("梯度函数: ", numpyTensor.grad_fn)

    
"""
numpyTensor:  tensor([[1, 2, 3],
        [4, 5, 6]])
形状:  torch.Size([2, 3])
数据类型:  torch.int64
放置设备(GPU|CPU):  cpu
自动求导属性:  False
梯度信息:  None
梯度函数:  None
"""

1.3 数据类型

在使用torch.tensor()函数创建张量时，可以使用参数dtype指定张量的元素类型，如:

# 指定张量类型为:torch.float32
torch.tensor([1, 2, 3], dtype=torch.float32)

以下是 torch.Tensor 支持的常见数据类型列表：

数据类型	描述
`torch.int8`	8位有符号整数
`torch.int16`	16位有符号整数
`torch.int32`	32位有符号整数
`torch.int64`	64位有符号整数
`torch.uint8`	8位无符号整数
`torch.float16`	16位浮点数
`torch.float32`	32位浮点数
`torch.float64`	64位浮点数
`torch.complex64`	64位复数（32位实部和虚部）
`torch.complex128`	128位复数（64位实部和虚部）
`torch.bool`	布尔类型（True 或 False）

2.张量创建

2.1 基于列表创建

import numpy as np
import torch

# 从list中创建张量
listTensor = torch.tensor([1, 2, 3])

2.2 基于numpy创建

import numpy as np
import torch
if __name__ == "__main__":
    # 从numpy中创建张量
    numpyArray = np.array([
        [1, 2, 3],
        [4, 5, 6]
    ])
    # 使用函数:from_numpy
    numpyTensorA = torch.from_numpy(numpyArray)
    print("numpyTensorA: ", numpyTensorA)
    # 使用函数: torch.tensor
    numpyTensorB = torch.tensor(numpyArray)
    print("numpyTensorB: ", numpyTensorB)

2.3 更多函数使用

PyTorch除了上面常用的torch.tensor创建张量函数外,还提供了很多便捷函数类创建张量，常用函数使用如下:

import torch

# -------------------- 特殊张量 --------------------
# 创建指定形状的全零张量
zeroTensor = torch.zeros((2, 3))

# 创建指定形状的全一张量
oneTensor = torch.ones((2, 3))

# 创建指定形状的单位矩阵
eyeTensor = torch.eye(3)

# 创建未初始化的张量
uninitializedTensor = torch.empty((2, 3))

# -------------------- END --------------------


# -------------------- 数学张量 --------------------
# 创建等差数列张量
arithmeticTensor = torch.arange(1, 10, 2)

# 创建随机张量（均匀分布）
randTensor = torch.rand((2, 3))

# 创建正态分布张量
randnTensor = torch.randn((2, 3))

# 创建指定范围内的均匀分布张量
linspaceTensor = torch.linspace(0, 1, 5)
# -------------------- END --------------------

# -------------------- 模仿创建 --------------------
# 原始张量
originalTensor = torch.tensor([[1, 2], [3, 4]])

# 创建与原始张量，形状一致，值都是0的张量
zerosLikeTensor = torch.zeros_like(originalTensor)

# 创建与原始张量，形状一致，值都是1的张量
onesLikeTensor = torch.ones_like(originalTensor)
# -------------------- END --------------------

3.张量访问

在 PyTorch 中，张量的常见访问方式包括索引、切片、以及一些常用的方法。以下是部分的代码示例：

3.1 使用索引

import numpy as np
import torch

if __name__ == "__main__":
    # 基于numpy创建多维张量
    npArray = np.arange(12).reshape(3, 4)
    npTensor = torch.tensor(npArray)
    print("多维张量:\n", npTensor)

    # 使用索引访问
    print("访问索引=0:", npTensor[0])
    print("访问索引=1:", npTensor[1])
    # 访问单个元素
    print("访问单个元素[0,2]:", npTensor[0, 2])
    print("访问单个元素[1,2]:", npTensor[1, 2])
    print("访问单个元素[2,2]:", npTensor[2, 2])
    
"""
多维张量:
 tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
访问索引=0: tensor([0, 1, 2, 3])
访问索引=1: tensor([4, 5, 6, 7])
访问单个元素[0,2]: tensor(2)
访问单个元素[1,2]: tensor(6)
访问单个元素[2,2]: tensor(10)
"""

3.2 使用切片

import numpy as np
import torch

if __name__ == "__main__":
    # 基于numpy创建多维张量
    npArray = np.arange(15).reshape(5, 3)
    npTensor = torch.tensor(npArray)
    print("多维张量:\n", npTensor)

    # 根据范围访问行数
    print("访问 npTensor[:2]: \n", npTensor[:2])
    print("访问 npTensor[1:3] \n", npTensor[1:3])
    # 访问具体行
    print("访问第一行: ", npTensor[0, :])
    # 访问具体列
    print("访问第二列: ", npTensor[:, 1])
    # 获取部分张量，从第二行开始（索引为1），取每行的前两列（索引为:2）
    print("获取部分张量: \n", npTensor[1:, :2])
    # 使用步长获取数据
    print("访问偶数列: \n", npTensor[::2])
    
"""
多维张量:
 tensor([[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11],
        [12, 13, 14]])
访问 npTensor[:2]: 
 tensor([[0, 1, 2],
        [3, 4, 5]])
访问 npTensor[1:3] 
 tensor([[3, 4, 5],
        [6, 7, 8]])
访问第一行:  tensor([0, 1, 2])
访问第二列:  tensor([ 1,  4,  7, 10, 13])
获取部分张量: 
 tensor([[ 3,  4],
        [ 6,  7],
        [ 9, 10],
        [12, 13]])
访问偶数列:
 tensor([[ 0,  1,  2],
        [ 6,  7,  8],
        [12, 13, 14]])
"""

4.张量运算

4.1 基本运算

import torch

if __name__ == "__main__":
    # 创建两个张量
    tensorA = torch.tensor([[1, 2], [3, 4]])
    tensorB = torch.tensor([[5, 6], [7, 8]])

    # 加法
    sumResult = tensorA + tensorB
    print("加法:\n", sumResult)

    # 减法
    subtraction_result = tensorA - tensorB
    print("减法:\n", subtraction_result)

    # 乘法（逐元素相乘）
    multiplyResult = tensorA * tensorB
    print("乘法: \n", multiplyResult)

    # 除法（逐元素相除）
    divideResult = tensorA / tensorB
    print("除法: \n", divideResult)
    
"""
加法:
 tensor([[ 6,  8],
        [10, 12]])
减法:
 tensor([[-4, -4],
        [-4, -4]])
乘法: 
 tensor([[ 5, 12],
        [21, 32]])
除法: 
 tensor([[0.2000, 0.3333],
        [0.4286, 0.5000]])
"""

4.2 统计运算

import torch
import numpy as np

if __name__ == "__main__":
    # 创建张量
    numpyArray = np.arange(12).reshape((3, 4))
    tensorData = torch.tensor(numpyArray)
    print("原始数据:\n", tensorData)

    # 求和
    sumTensor = torch.sum(tensorData)
    print("求和:", sumTensor)
    # 平均值
    meanTensor = torch.mean(tensorData.float())
    print("平均值:", meanTensor)

    # 转换为浮点数类型
    # 标准差和方差仅支持浮点数和复数类型的张量，不支持整数类型的张量。在进行这两个操作之前，需要将张量的数据类型转换为浮点数或复数类型。
    tensorFloat = tensorData.float()
    # 标准差
    stdTensor = torch.std(tensorFloat)
    print("标准差:", stdTensor.item())
    # 方差
    varianceTensor = torch.var(tensorFloat)
    print("方差:", varianceTensor.item())

    # 最大值
    maxTensor = torch.max(tensorData)
    print("最大值:", maxTensor.item())

    # 最小值
    minTensor = torch.min(tensorData)
    print("最小值:", minTensor.item())

    # 按维度进行统计运算
    dimSumTensor = torch.sum(tensorData, dim=0)
    print("计算每列(dim=0)的和: \n", dimSumTensor)

    dimMeanTensor = torch.mean(tensorFloat, dim=0)
    print("计算每列(dim=0)的平均值: \n", dimMeanTensor)
    
    
"""
原始数据:
 tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
求和: tensor(66)
平均值: tensor(5.5000)
标准差: 3.605551242828369
方差: 13.0
最大值: 11
最小值: 0
计算每列(dim=0)的和: 
 tensor([12, 15, 18, 21])
计算每列(dim=0)的平均值: 
 tensor([4., 5., 6., 7.])
"""

4.3 矩阵运算

import torch
if __name__ == "__main__":
    # 创建一个二维张量（矩阵）
    matrix_a = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    # 转置
    transposed_matrix_a = matrix_a.T
    print("转置:\n", transposed_matrix_a)
    # 矩阵乘法
    matrix_b = torch.tensor([[2, 0, 1], [1, 2, 3], [4, 5, 6]])
    matrix_multiply_result = torch.matmul(matrix_a, matrix_b)
    print("矩阵乘法:\n", matrix_multiply_result)
    
"""
转置:
 tensor([[1, 4, 7],
        [2, 5, 8],
        [3, 6, 9]])
矩阵乘法:
 tensor([[16, 19, 25],
        [37, 40, 55],
        [58, 61, 85]])
"""