深入学习Pytorch：第一章-初步认知

Pytorch简介

PyTorch 是一个开源的深度学习框架，由 Facebook（现 Meta）的人工智能研究团队于2016年推出。它以灵活性和动态计算图著称，广泛应用于学术研究和工业领域。

核心特性

• 动态计算图（Dynamic Computation Graph）
  支持在运行时定义和修改计算图（即“Define-by-Run”模式），便于调试和实现复杂模型（如循环神经网络、动态结构模型）。

• 张量运算（Tensor Operations）
  提供类似 NumPy 的多维数组（torch.Tensor），支持 GPU 加速计算，并包含高效的数学运算库（如矩阵操作、自动广播）。

• 自动微分（Autograd）
  通过 autograd 模块自动计算梯度，无需手动实现反向传播，简化了模型训练流程。

• 模块化神经网络（Neural Network Modules）
  torch.nn 模块提供了预定义的层（如卷积层、LSTM）、损失函数和优化器（如 SGD、Adam），支持快速搭建复杂模型。

• 分布式训练
  支持多GPU并行训练和分布式计算（通过 torch.distributed），适合处理大规模数据和模型。

安装

进入官方网站 根据实际情况进行选择，生产命令进行执行

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

机器学习的基本流程

Pytorch线性回归模型

基本的处理流程如下

1. 加载数据
2. 初始化模型
3. 设置损失函数和优化方法
4. 训练模型
5. 使用模型进行预测

	import os
	os.environ['kmp_duplicate_lib_ok'] = "TRUE"
	import torch
	import torch.nn as nn
	import numpy as np
	import matplotlib.pyplot as plt

	### 线性模型训练：y=w*x+b

	# 1. 定义训练集合
	x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
	                    [9.779], [6.182], [7.59], [2.167], [7.042],
	                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)

	y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
	                    [3.366], [2.596], [2.53], [1.221], [2.827],
	                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)

	# 2. 设置线性模型，nn是重要的模块
	input_size = 1
	output_size = 1
	model = nn.Linear(input_size, output_size)
	# 3. 设置损失函数和优化方法。损失函数计算误差；根据优化方法调整参数，目标是生成w,b；learning_rate相当于梯度下降的移动步长
	learning_rate = 0.001
	criterion = nn.MSELoss()
	optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, )

	# 4. 训练模型
	num_epochs = 100  # 定义训练次数
	for epoch in range(num_epochs):
	    # 数据转换为Tensor
	    inputs = torch.from_numpy(x_train)
	    targets = torch.from_numpy(y_train)

	    # 放入模型中进行计算，得到输出
	    outputs = model(inputs)
	    # 通过损失函数计算误差（使用输出值与目标值进行）
	    loss = criterion(outputs, targets)
	    # 优化函数中的梯度清零，不清零可能有累积
	    optimizer.zero_grad()
	    # 反向传播，进行梯度计算
	    loss.backward()
	    # 沿着梯度方向进行参数调整
	    optimizer.step()

	    # 输出一些统计信息
	    if (epoch+1) % 5 == 0:
	        print('Epoch [{}/{}], loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

	# 输出最终生成的模型数据，这里仅限于线性模型的生成数据
	print(model.weight)
	print(model.bias)
	# 5. 通过模型进行预测
	# 模型设置为评估状态
	model.eval()
	x_test = np.array([[6.5]], dtype=np.float32)
	# 禁用梯度计算
	with torch.no_grad():
	  predictions = model(torch.from_numpy(x_test))  # 使用模型进行预测
	  print(predictions.data.numpy())

	# 显示模型
	# Plot the graph
	predicted = model(torch.from_numpy(x_train)).detach().numpy()
	plt.plot(x_train, y_train, 'ro', label='Original data')
	plt.plot(x_train, predicted, label='Fitted line')
	plt.legend()
	plt.show()

Pytorch线性回归写法分解

上面的线性模型使用了Pytorch提供的很多方法，为了更好的进行理解，将上面的写法进行分解
分解的内容包括：模型的定义，损失函数、优化函数的写法，模型训练的写法

	import os
	os.environ['kmp_duplicate_lib_ok'] = "TRUE"
	import torch
	import numpy as np

	### 线性模型训练：y=w*x+b

	# 1. 定义训练集合
	x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
	                    [9.779], [6.182], [7.59], [2.167], [7.042],
	                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)

	y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
	                    [3.366], [2.596], [2.53], [1.221], [2.827],
	                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)

	# 2. 设置线性模型，nn是重要的模块
	input_size = 1
	output_size = 1
	# 修改模型，改为自定义y=w*x+b; model = nn.Linear(input_size, output_size)
	w = torch.randn(input_size, requires_grad=True) # 跟踪变量运算
	b = torch.zeros(output_size, requires_grad=True)

	# 3. 设置损失函数和优化方法。损失函数计算误差；根据优化方法调整参数，目标是生成w,b；learning_rate相当于梯度下降的移动步长
	learning_rate = 0.001
	# 修改损失函数，在下面的训练中直接修改； criterion = nn.MSELoss()
	# 修改优化函数，在下面的训练中直接修改； optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, )

	# 4. 训练模型
	num_epochs = 100  # 定义训练次数
	for epoch in range(num_epochs):
	    # 数据转换为Tensor
	    inputs = torch.from_numpy(x_train)
	    targets = torch.from_numpy(y_train)

	    for x, y in zip(inputs, targets):
	        # 放入模型中进行计算，得到输出
	        y_pred = torch.matmul(x,w) + b # 进行模型计算
	        # 通过损失函数计算误差（使用输出值与目标值进行）
	        loss = (y - y_pred).pow(2).mean() # 均方误差，差的评分求均值
	        # 优化函数中的梯度清零，不清零可能有累积
	        if not w.grad is None:
	            w.grad.data.zero_()
	        if not b.grad is None:
	            b.grad.data.zero_()
	        # 反向传播，进行梯度计算
	        loss.backward() # 计算梯度，找到下降最快的位置
	        # 沿着梯度方向进行参数调整
	        with torch.no_grad():
	            w.data -= w.grad.data * learning_rate  # 减去梯度*学习率
	            b.data -= b.grad.data * learning_rate

	        # 输出一些统计信息
	        if (epoch+1) % 5 == 0:
	            print('Epoch [{}/{}], loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

	# 输出最终生成的模型数据，这里仅限于线性模型的生成数据
	print(w)
	print(b)
	# 5. 通过模型进行预测
	with torch.no_grad():
	    test = 6.5
	    value = w * 6.5 + b
	    print(value.data)

总结说明

上面是一个简单的基于Pythorch的线性回归使用例子，目的是对Pythorch有一个初步的认知，后续会逐步深入进行更详细的相关讲解