pytorch使用
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE" #原始环境为了避免混乱的包冲突
1. 张量（tensor）
import torch
import numpy as np
1.1 初始化
data = [[1, 2],[3, 4]]
x_data = torch.tensor(data) #从列表初始化
np_array = np.array(data)
x_data = torch.from_numpy(np_array) #从numpy初始化
x_ones = torch.ones_like(x_data) #保持相同规模，全部置1
x_rand = torch.rand_like(x_data, dtype=torch.float) #保持相同规模，生成随机数
根据维度进行初始化
shape = (2,3,)
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)
1.2 张量运算
像numpy一样进行索引和切片
tensor[0] #第一行
tensor[：，0] #第一列
tensor[...,-1] #最后一列
t1 = torch.cat([tensor, tensor, tensor], dim=1) #进行拼接
算数运算
#内积
tensor*tensor tensor.mul(tensor)
#矩阵乘法
X@X X.matmul(X)
tensor.sum() #所有元素求和
#增加_ , 进行原地操作
tensor.add_(5) #所有元素增加5
内存共享(可以轻松使用numpy的所有运算)
#从tensor生成numpy , 与从numpy生成tensor，二者内存共享
np_ = tensor.numpy()
tensor = torch.from_numpy(np_)
2. 数据集和数据读取
2.1 可视化(随机展示9张图片)
import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plt
#training_data每个索引包含一个元组，第一个数据为图像tensor，第二个数据为预测类别int
figure = plt.figure(figsize=(8, 8)) #创建一个图像对象，尺寸为8X8
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
sample_idx = torch.randint(len(training_data), size=(1,)).item() #生成随机索引
img, label = training_data[sample_idx] #根据索引读取图片和预测标签
figure.add_subplot(rows, cols, i) #在3X3的子图网格中添加子图
plt.title(label) #可以让预测标签映射到实际名字作为显示
plt.axis("off")
plt.imshow(img.squeeze(), cmap="gray") #显示压缩的灰度图
plt.show()
2.2 自定义数据集类进行读取
import os
import pandas as pd
from torchvision.io import read_image
class CustomImageDataset(Dataset): #继承自Dataset的类
自定义数据集类必须包含三部分：__init__, __len__, and __getitem__
def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
self.img_labels = pd.read_csv(annotations_file) #图片名字和对应标签
self.img_dir = img_dir #图片路径
self.transform = transform
self.target_transform = target_transform
def __len__(self):
return len(self.img_labels) #数据的个数
def __getitem__(self, idx):
img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0]) #拼接图像路径，和图像名称
image = read_image(img_path) #读取图片成张量格式
label = self.img_labels.iloc[idx, 1] #对应图片的标签
if self.transform:
image = self.transform(image)
if self.target_transform:
label = self.target_transform(label)
return image, label #返回图像和对应标签
2.3 数据洗牌和迭代
from torch.utils.data import DataLoader
train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)
train_features, train_labels = next(iter(train_dataloader)) #每次可以得到64个随机数据
2.4 Transforms
简单处理
transform=ToTensor(), #对数据进行处理，这里是变成张量格式，同时归一化处理
#对标签数据进行处理，这里是根据类别进行one-hot编码
target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))
Script the transformation
transforms = torch.nn.Sequential(
transforms.CenterCrop(10),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
)
scripted_transforms = torch.jit.script(transforms)
3. 建立一个神经网络
import os
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
device = ( #检验cuda能否使用
"cuda"
if torch.cuda.is_available()
else "mps"
if torch.backends.mps.is_available()
else "cpu"
)
print(f"Using {device} device")
class NeuralNetwork(nn.Module): #注意这里的模型是有参数的（权重和偏差）
def __init__(self):
super().__init__() #父类初始化
self.flatten = nn.Flatten() #将二维图像展平成一维向量
self.linear_relu_stack = nn.Sequential( #按序组合多个层
nn.Linear(28*28, 512), #全连接层，将28×28图像展平后，连接到512神经元的隐藏层
nn.ReLU(), #ReLU激活函数
nn.Linear(512, 512), #全连接层，将512隐藏层输出连接到另一个512隐藏层
nn.ReLU(), #ReLU激活函数
nn.Linear(512, 10), #全连接层，将512隐藏层输出连接到10维的输出层
)
def forward(self, x): #前向传播
x = self.flatten(x)
logits = self.linear_relu_stack(x)
return logits
model = NeuralNetwork().to(device) #j将这个类放到gpu上
4. 完整的前向传播和反向传播
一次训练迭代过程过程
def train_loop(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset) #总训练数据集大小
model.train()
for batch, (X, y) in enumerate(dataloader):
# Compute prediction and loss
pred = model(X)
loss = loss_fn(pred, y)
# Backpropagation
loss.backward()
optimizer.step()
optimizer.zero_grad()
if batch % 100 == 0: #每一百轮输出一次
loss, current = loss.item(), (batch + 1) * len(X)
print(f"loss: {loss:>7f} [{current:>5d}/{size:>5d}]")
def test_loop(dataloader, model, loss_fn):
# Set the model to evaluation mode - important for batch normalization and dropout layers
# Unnecessary in this situation but added for best practices
model.eval()
size = len(dataloader.dataset)
num_batches = len(dataloader)
test_loss, correct = 0, 0
# Evaluating the model with torch.no_grad() ensures that no gradients are computed during test mode
# also serves to reduce unnecessary gradient computations and memory usage for tensors with requires_grad=True
with torch.no_grad():
for X, y in dataloader:
pred = model(X)
test_loss += loss_fn(pred, y).item()
correct += (pred.argmax(1) == y).type(torch.float).sum().item()
test_loss /= num_batches
correct /= size
print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
进行多次迭代更新参数
model = NeuralNetwork()
epochs = 10
for t in range(epochs):
print(f"Epoch {t+1}\n-------------------------------")
train_loop(train_dataloader, model, loss_fn, optimizer)
test_loop(test_dataloader, model, loss_fn)
print("Done!")
存储模型
torch.save(model, 'model.pth')
model = torch.load('model.pth')
