目录
[1 导入数据集](#1 导入数据集)
[2 使用tensorboard展示经过各个层的图片数据](#2 使用tensorboard展示经过各个层的图片数据)
[3 完整的模型训练测试流程](#3 完整的模型训练测试流程)
[4 加载训练好的模型进行测试](#4 加载训练好的模型进行测试)
1 导入数据集
python
import torch
from torch.utils.data import DataLoader
import torchvision
from torchvision import transforms
import torch.nn as nn
# 准备数据集
from torch.utils.tensorboard import SummaryWriter
train_data = torchvision.datasets.CIFAR10('./data', train=True, transform=transforms.ToTensor(), download=True)
print("train数据", train_data)
print(f"train_data数据的长度是{len(train_data)}")
train_data = DataLoader(dataset=train_data, batch_size=64, shuffle=True)
print("------------------------------------------")
test_data = torchvision.datasets.CIFAR10('./data', train=False, transform=transforms.ToTensor(), download=True)
print("test数据", test_data)
print(f"test_data数据的长度是{len(test_data)}")
print("第一条数据",test_data[0])
test_data = DataLoader(dataset=test_data, batch_size=64, shuffle=True)train数据 Dataset CIFAR10
Number of datapoints: 50000
Root location: ./data
Split: Train
StandardTransform
Transform: ToTensor()
train_data数据的长度是50000
Files already downloaded and verified
test数据 Dataset CIFAR10
Number of datapoints: 10000
Root location: ./data
Split: Test
StandardTransform
Transform: ToTensor()
test_data数据的长度是10000
第一条数据 (tensor([[[0.6196, 0.6235, 0.6471, ..., 0.5373, 0.4941, 0.4549],
[0.5961, 0.5922, 0.6235, ..., 0.5333, 0.4902, 0.4667],
[0.5922, 0.5922, 0.6196, ..., 0.5451, 0.5098, 0.4706],
...,
[0.2667, 0.1647, 0.1216, ..., 0.1490, 0.0510, 0.1569],
[0.2392, 0.1922, 0.1373, ..., 0.1020, 0.1137, 0.0784],
[0.2118, 0.2196, 0.1765, ..., 0.0941, 0.1333, 0.0824]],
[[0.4392, 0.4353, 0.4549, ..., 0.3725, 0.3569, 0.3333],
[0.4392, 0.4314, 0.4471, ..., 0.3725, 0.3569, 0.3451],
[0.4314, 0.4275, 0.4353, ..., 0.3843, 0.3725, 0.3490],
2 使用tensorboard展示经过各个层的图片数据
python
class convModel(nn.Module):
def __init__(self):
super(convModel, self).__init__()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, stride=1, padding=0, bias=True, padding_mode='zeros', kernel_size=3)
def forward(self, input_data):
return self.conv1(input_data)
write = SummaryWriter('convModel')
model = convModel()
for batch_id, data in enumerate(test_data):
write.add_images('原始图片数据展示', data[0], dataformats='NCHW', global_step=batch_id)
input_data, label = data[0],data[1]
print("batchSize",input_data.size(0))
output_data = model(input_data)
# 因为经过卷积之后，通道数变为6了，而add_images的源码中要求的通道个数是4个，所以要进行通道变换
output_shape_data = torch.reshape(output_data,(-1,3,30,30))
write.add_images('经过卷积层之后的图片数据展示', output_shape_data, global_step=batch_id)
if batch_id % 300 == 0:
print("原始数据的形状", input_data.shape)
print("经过卷积层之后的形状", output_data.shape)
print("经过形状改变之后", output_shape_data.shape)
write.close()batchSize 64
原始数据的形状 torch.Size([64, 3, 32, 32])
经过卷积层之后的形状 torch.Size([64, 6, 30, 30])
经过形状改变之后 torch.Size([128, 3, 30, 30])
batchSize 64
batchSize 64
batchSize 64
batchSize 64
batchSize 64
batchSize 64
batchSize 64
python
class maxPoolingModel(nn.Module):
def __init__(self):
super(maxPoolingModel, self).__init__()
self.MaxPool2d = nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=False)
def forward(self, input_data):
return self.MaxPool2d(input_data)
write = SummaryWriter('maxPoolingModel')
model = maxPoolingModel()
for batch_id, data in enumerate(test_data):
write.add_images('原始图片数据展示', data[0], dataformats='NCHW', global_step=batch_id)
input_data, label = data[0],data[1]
output_data = model(input_data)
write.add_images('经过池化层之后的图片数据展示', output_data, global_step=batch_id)
if batch_id % 300 == 0:
print("原始数据的形状", input_data.shape)
print("经过池化层之后的形状", output_data.shape)
write.close()原始数据的形状 torch.Size([64, 3, 32, 32])
经过池化层之后的形状 torch.Size([64, 3, 16, 16])
python
class unLineModel(nn.Module):
def __init__(self):
super(unLineModel, self).__init__()
self.sigmoid = nn.Sigmoid()
def forward(self, input_data):
return self.sigmoid(input_data)
write = SummaryWriter('unLineModel')
model = unLineModel()
for batch_id, data in enumerate(test_data):
write.add_images('原始图片数据展示', data[0], dataformats='NCHW', global_step=batch_id)
input_data, label = data[0],data[1]
output_data = model(input_data)
write.add_images('经过非线性层之后的图片数据展示', output_data, global_step=batch_id)
if batch_id % 300 == 0:
print("原始数据的形状", input_data.shape)
print("经过非线性层之后的形状", output_data.shape)
write.close()原始数据的形状 torch.Size([64, 3, 32, 32])
经过非线性层之后的形状 torch.Size([64, 3, 32, 32])
3 完整的模型训练测试流程
python
class Model(nn.Module):
def __init__(self):
super(Model,self).__init__()
self.model = nn.Sequential(
nn.Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2,stride=1),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2,stride=1),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2,stride=1),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Flatten(),
nn.Linear(in_features=1024, out_features=64),
nn.Linear(in_features=64, out_features=10)
)
def forward(self, batch_data):
return self.model(batch_data)
# 第一种方式：使用cuda，只需要给模型、损失函数、训练数据、测试数据调用cuda即可，但是这种情况下必须使用if torch.cuda.is_available():判断是否存在cuda，没有的话还是使用cpu，但是没有使用torch.cuda.is_available()判断的话会出错，导致程序无法运行
# 第二种方式：cuda：0 单个显卡
device = torch.device("cuda:0" if torch.cuda.is_available() else 'cpu')
model = Model()
model.to(device=device)
print(model)
batch_data = torch.ones((64,3,32,32)).to(device)
output = model(batch_data)
print("output.shape", output.shape)Model(
(model): Sequential(
(0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
(1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
(3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
(5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(6): Flatten(start_dim=1, end_dim=-1)
(7): Linear(in_features=1024, out_features=64, bias=True)
(8): Linear(in_features=64, out_features=10, bias=True)
使用Gpu训练的两种方式
# 第一种方式：使用cuda，只需要给模型、损失函数、训练数据、测试数据调用cuda即可，但是这种情况下必须使用if torch.cuda.is_available():判断是否存在cuda，没有的话还是使用cpu，但是没有使用torch.cuda.is_available()判断的话会出错，导致程序无法运行 # 第二种方式：cuda：0 单个显卡 device = torch.device("cuda:0" if torch.cuda.is_available() else 'cpu')，在这种情况写，只需要将对应的模型、损失函数、训练数据、测试数据使用to调用device上即可
使用tensorboard显示模型
python
from torch.utils.tensorboard import SummaryWriter
write = SummaryWriter('model')
write.add_graph(model=model,input_to_model=batch_data)
write.close()模型训练测试
python
# -------------------------CrossEntropyLoss()维度要求的底层源码-------------------
# Shape:
# - Input: :math:`(N, C)` where `C = number of classes`, or
# :math:`(N, C, d_1, d_2, ..., d_K)` with :math:`K \geq 1`
# in the case of `K`-dimensional loss.
# - Target: :math:`(N)` where each value is :math:`0 \leq \text{targets}[i] \leq C-1`, or
# :math:`(N, d_1, d_2, ..., d_K)` with :math:`K \geq 1` in the case of
# K-dimensional loss.
# - Output: scalar.
# If :attr:`reduction` is ``'none'``, then the same size as the target:
# :math:`(N)`, or
# :math:`(N, d_1, d_2, ..., d_K)` with :math:`K \geq 1` in the case
# of K-dimensional loss.
criteria = nn.CrossEntropyLoss()
criteria.to(device)
nn.L1Loss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
sum_loss_list = []
epoch_list = []
from torch.utils.tensorboard import SummaryWriter
write = SummaryWriter("figure")
total_train_step = 0
total_test_step = 0
for epoch in range(50):
ever_epoch_loss_sum = 0.0
print("---------------------第 {} 轮训练开始---------------------".format(epoch+1))
model.train()
for batch_id, data in enumerate(train_data):
input_data, input_label = data
input_data = input_data.to(device)
input_label = input_label.to(device)
output_data = model(input_data)
# if batch_id%300 == 0:
# print("input_data", input_data.shape) # input_data torch.Size([64, 3, 32, 32])
# print("output_data", output_data.shape) # output_data torch.Size([64, 10])
# print("input_label", input_label.shape) # input_label torch.Size([64])
loss = criteria(output_data, input_label)
ever_epoch_loss_sum = ever_epoch_loss_sum + loss.item()
loss.backward()
optimizer.step()
optimizer.zero_grad()
if total_train_step % 200 == 0:
print("当前总的训练次数：{} ，每一次的Loss：{}".format(total_train_step, loss.item()))
write.add_scalar('train_loss', loss.item(), total_train_step)
total_train_step = total_train_step + 1
sum_loss_list.append(ever_epoch_loss_sum)
epoch_list.append(epoch)
print("---------------------第 {} 轮测试开始---------------------".format(epoch+1))
model.eval()
total_test_loss = 0
total_accuracy = 0
with torch.no_grad():
for batch_id, data in enumerate(test_data):
images, label = data
images = images.to(device)
label = label.to(device)
output = model(images)
loss = criteria(output,label)
total_test_loss = total_test_loss + loss.item()
accuracy = (output.argmax(1) == label).sum()
total_accuracy = total_accuracy + accuracy
print("整体测试集上的Loss： {}".format(total_test_loss))
print("整体数据集上的正确率：{}".format(total_accuracy/len(test_data)))
write.add_scalar("test_accuracy",total_accuracy/len(test_data),total_test_step)
write.add_scalar('test_loss', total_test_loss, total_test_step)
total_test_step = total_test_step + 1
torch.save(model,'model_{}.pth'.format(epoch))
print("保存第 {} 轮模型".format(epoch+1))
write.close()L1Loss函数
python
inputs = torch.tensor([1,2,3], dtype=torch.float32)
print("原始数据inputs", inputs)
print("原始数据形状inputs.shape", inputs.shape)
targets = torch.tensor([1,2,5], dtype=torch.float32)
print("目标数据targets", targets)
print("目标数据形状targets.shape", targets.shape)
inputs = torch.reshape(inputs,(1,-1))
print("形状改变数据inputs", inputs)
print("形状改变数据形状inputs.shape", inputs.shape)
targets = torch.reshape(targets,(1,-1))
print("目标数据改变targets", targets)
print("目标数据形状改变targets.shape", targets.shape)
loss = nn.L1Loss()
# - Input: :math:`(N, *)` where :math:`*` means, any number of additional
# dimensions
# - Target: :math:`(N, *)`, same shape as the input
result = loss(inputs, targets)
print(result)原始数据inputs tensor([1., 2., 3.])
原始数据形状inputs.shape torch.Size([3])
目标数据targets tensor([1., 2., 5.])
目标数据形状targets.shape torch.Size([3])
形状改变数据inputs tensor([[1., 2., 3.]])
形状改变数据形状inputs.shape torch.Size([1, 3])
目标数据改变targets tensor([[1., 2., 5.]])
目标数据形状改变targets.shape torch.Size([1, 3])
tensor(0.6667)
保存未训练模型或者已经训练完的模型
python
# 模型的保存
torch.save(model,'class_model.pth')
# 模型加载，但是这种情况下如果加载的模型和原本的模型没有在同一个文件中，那么需要将原本的模型使用from加载到当前文件中，再使用torch.load
model = torch.load('class_model.pth')
print(model)4 加载训练好的模型进行测试
python
import torch.nn as nn
import torch
class Model(nn.Module):
def __init__(self):
super(Model,self).__init__()
self.model = nn.Sequential(
nn.Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2,stride=1),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2,stride=1),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2,stride=1),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Flatten(),
nn.Linear(in_features=1024, out_features=64),
nn.Linear(in_features=64, out_features=10)
)
def forward(self, batch_data):
return self.model(batch_data)
load_model = torch.load('G:\python_files\深度学习代码库\model_49.pth') # 加载模型，使用上面的非字典形式保存的模型，这个时候加载的时候必须把原本定义的模型加载到当前文件，然后使用该函数加载。同时需要注意，如果加载的模型原本是在cuda上跑的，这个时候要将模型使用load函数的参数map_location=torch.device('cpu')加载到cpu上，或者也可以将图片的数据放入到gpu上，与原本的模型对应起来
from torchvision import transforms
from PIL import Image
image = Image.open('G:\python_files\深度学习代码库\cats\cat\cat.10.jpg')
trans = transforms.Compose([transforms.Resize((32,32)),transforms.ToTensor()])
trans_image_tensor = trans(image)
# 因为上面的模型训练的时候输入是(NCHW)，所以将训练完的模型加载进来使用测试的时候必须要将一张图片reshape模型需要的形状，否则就会报错
tensor_shape = torch.reshape(trans_image_tensor,(1,3,32,32)).to(torch.device("cuda:0"))
load_model.eval()
with torch.no_grad():
output = load_model(tensor_shape)
print(output)注意事项：
load_model = torch.load('G:\python_files\深度学习代码库\model_49.pth') # 加载模型，使用上面的非字典形式保存的模型，这个时候加载的时候必须把原本定义的模型加载到当前文件，然后使用该函数加载。同时需要注意，如果加载的模型原本是在cuda上跑的，这个时候要将模型使用load函数的参数map_location=torch.device('cpu')加载到cpu上，或者也可以将图片的数据放入到gpu上，与原本的模型对应起来
# 因为上面的模型训练的时候输入是(NCHW)，所以将训练完的模型加载进来使用测试的时候必须要将一张图片reshape模型需要的形状，否则就会报错 tensor_shape = torch.reshape(trans_image_tensor,(1,3,32,32)).to(torch.device("cuda:0"))