PyTorch 基础学习（2）- 张量 Tensors

PyTorch张量简介

张量是数学和计算机科学中的一个基本概念，用于表示多维数据，是AI世界中一切事物的表示和抽象。可以将张量视为一个扩展了标量、向量和矩阵的通用数据结构。以下是对张量的详细解释：

张量的定义

1. 标量（0阶张量）：标量是一个单一的数值，例如 3 或 -1.5。

2. 向量（1阶张量）：向量是一维数组，可以表示为一列或一行数值，例如 ([1, 2, 3])。

3. 矩阵（2阶张量）：矩阵是一个二维数组，包含行和列，例如：

   

4. 高阶张量：高阶张量是更高维度的数组。例如，三阶张量可以被视为一个矩阵的集合，每个矩阵位于一个"层"上，如下所示：

   

张量的特点

• 维度（阶）：张量的维度指的是数据的方向数。例如，一个三阶张量可以用一个3D数组表示，其中每个维度称为一个轴。

• 形状：张量的形状由沿每个轴的元素数量定义。例如，形状为(3, 4, 5)的张量意味着它有3个“层”，每个“层”包含4行5列的数据。

• 数据类型：张量可以存储不同类型的数据，如整数、浮点数等。

张量在机器学习中的应用

在深度学习和机器学习中，张量是处理和操作数据的基础。以下是一些应用示例：

1. 图像数据：图像通常表示为3阶张量，其中维度分别表示高度、宽度和颜色通道。

2. 时间序列数据：时间序列数据可以表示为2阶张量，其中一个维度表示时间步，另一个维度表示特征。

3. 神经网络权重：在神经网络中，权重和偏置通常存储为张量，以便进行高效的计算。

将图像转换成张量

from PIL import Image
from torchvision import transforms

# 第一步：加载图像
image_path = 'path_to_your_image.jpg'  # 替换为你的图像路径
image = Image.open(image_path)

# 第二步：定义转换
transform = transforms.Compose([
    transforms.ToTensor()  # 将图像转换为张量，并将像素值归一化到[0, 1]之间
])

# 第三步：应用转换
image_tensor = transform(image)

# 查看结果
print(f"张量形状: {image_tensor.shape}")  # 输出张量形状，通常为 (C, H, W)
print(f"数据类型: {image_tensor.dtype}")  # 输出张量的数据类型

输出：

张量形状: torch.Size([3, 1024, 1024])  //一幅三通道（RGB）的 1024x1024 像素图像。
数据类型: torch.float32 //张量的数据类型为32位浮点数

张量计算

PyTorch等深度学习框架利用张量作为基本数据结构，因为它们可以高效地在GPU上进行并行计算。张量支持多种数学运算，如加法、乘法、转置、索引和切片等，这使得它们非常适合处理复杂的数据计算任务。

总结来说，张量是一个灵活且高效的数据结构，广泛用于科学计算、图像处理、自然语言处理等领域。通过使用张量，我们可以在计算机中有效地表示和操作高维数据。

张量操作

1. 张量检测

   • torch.is_tensor(obj)：判断对象obj是否是一个PyTorch张量，返回True或False。

2. 元素个数

   • torch.numel(input)：返回张量input中的元素个数。

   import torch
   
   a = torch.randn(1, 2, 3, 4, 5)
   print(torch.numel(a))  # 输出: 120
   

3. 设置默认张量类型

   • torch.set_default_tensor_type(t)：设置默认的张量类型。

4. 打印选项

   • torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None)：设置张量打印的选项，如精度、行宽等。

张量创建

1. 单位矩阵

   • torch.eye(n, m=None, out=None)：返回一个2D单位矩阵。

   print(torch.eye(3))
   

2. 从Numpy数组创建张量

   • torch.from_numpy(ndarray)：将Numpy数组转换为PyTorch张量。

   import numpy as np
   
   a = np.array([1, 2, 3])
   t = torch.from_numpy(a)
   

3. 线性间隔张量

   • torch.linspace(start, end, steps=100, out=None)：创建一个1D张量，包含从start到end的等间隔数值。

   print(torch.linspace(3, 10, steps=5))
   

4. 对数间隔张量

   • torch.logspace(start, end, steps=100, out=None)：在对数尺度上创建等间隔数值的1D张量。

   print(torch.logspace(start=0.1, end=1.0, steps=5))
   

5. 全1张量

   • torch.ones(*sizes, out=None)：创建一个形状为sizes的全1张量。

   print(torch.ones(2, 3))
   

6. 随机张量

   • torch.rand(*sizes, out=None)：创建一个形状为sizes的张量，包含均匀分布的随机数。
   • torch.randn(*sizes, out=None)：创建一个形状为sizes的张量，包含标准正态分布的随机数。

7. 排列张量

   • torch.randperm(n, out=None)：生成从0到n-1的随机排列。

   print(torch.randperm(4))
   

索引与切片

1. 张量连接

   • torch.cat(inputs, dimension=0)：在给定维度上连接张量序列。

   x = torch.randn(2, 3)
   print(torch.cat((x, x, x), 0))
   

2. 张量分块

   • torch.chunk(tensor, chunks, dim=0)：将张量分成指定数量的块。

3. 选择性索引

   • torch.index_select(input, dim, index, out=None)：在指定维度上选择特定的索引项。

   x = torch.randn(3, 4)
   indices = torch.LongTensor([0, 2])
   print(torch.index_select(x, 0, indices))
   

4. 非零元素索引

   • torch.nonzero(input, out=None)：返回一个张量，包含非零元素的索引。

   print(torch.nonzero(torch.Tensor([1, 1, 0, 0, 1])))
   

5. 挤压与扩展

   • torch.squeeze(input, dim=None, out=None)：移除形状中的1。
   • torch.unsqueeze(input, dim, out=None)：在指定位置插入维度1。

   x = torch.Tensor([1, 2, 3, 4])
   print(torch.unsqueeze(x, 0))
   

随机抽样

1. 设定随机数种子

   • torch.manual_seed(seed)：设定随机数生成的种子。

2. 伯努利分布

   • torch.bernoulli(input, out=None)：从伯努利分布中抽取二元随机数。

   a = torch.Tensor(3, 3).uniform_(0, 1)
   print(torch.bernoulli(a))
   

3. 多项分布抽样

   • torch.multinomial(input, num_samples, replacement=False, out=None)：从多项分布中抽取样本。

4. 正态分布

   • torch.normal(means, std, out=None)：从正态分布中抽取样本。

   print(torch.normal(means=torch.arange(1, 6)))
   

序列化

1. 保存对象

   • torch.save(obj, f)：保存对象到文件。

2. 加载对象

   • torch.load(f, map_location=None)：从文件加载对象。

并行化

1. 获取和设置线程数
   • torch.get_num_threads()：获取用于并行化CPU操作的线程数。
   • torch.set_num_threads(int)：设置用于并行化CPU操作的线程数。

应用实例：线性回归模型

下面是一个简单的线性回归模型示例，展示了如何使用上述PyTorch操作实现基本的机器学习任务。

import torch
import torch.nn as nn
import torch.optim as optim

# 生成随机数据
x = torch.rand(100, 1) * 10  # 100个样本，每个样本有1个特征
y = 2 * x + 3 + torch.randn(100, 1)  # y = 2*x + 3 + 噪声

# 定义线性模型
model = nn.Linear(1, 1)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
for epoch in range(1000):
    # 前向传播
    outputs = model(x)
    loss = criterion(outputs, y)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 100 == 0:
        print(f'Epoch [{epoch+1}/1000], Loss: {loss.item():.4f}')

# 打印模型参数
[w, b] = model.parameters()
print(f'Weight: {w.item()}, Bias: {b.item()}')

输出：

......
Epoch [800/1000], Loss: 1.1024
Epoch [900/1000], Loss: 1.1014
Epoch [1000/1000], Loss: 1.1011
Weight: 1.9926187992095947, Bias: 3.0762107372283936

总结

本教程介绍了PyTorch中的基本张量操作，包括创建、索引、随机采样、序列化和并行化等。通过实例演示了如何使用这些操作构建一个简单的线性回归模型。掌握这些基本操作能够帮助开发者更高效地进行深度学习模型的构建与优化。