电脑自助建站,php 小企业网站 cms,做团购网站视频,网站建设 话术目录 1 导入数据集 2 使用tensorboard展示经过各个层的图片数据 3 完整的模型训练测试流程 使用Gpu训练的两种方式 使用tensorboard显示模型 模型训练测试 L1Loss函数 保存未训练模型或者已经训练完的模型 4 加载训练好的模型进行测试 1 导入数据集
import torch
from torch.u… 目录 1 导入数据集 2 使用tensorboard展示经过各个层的图片数据 3 完整的模型训练测试流程 使用Gpu训练的两种方式 使用tensorboard显示模型 模型训练测试 L1Loss函数 保存未训练模型或者已经训练完的模型 4 加载训练好的模型进行测试 1 导入数据集
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, trainTrue, transformtransforms.ToTensor(), downloadTrue)
print(train数据, train_data)
print(ftrain_data数据的长度是{len(train_data)})
train_data DataLoader(datasettrain_data, batch_size64, shuffleTrue)
print(------------------------------------------)
test_data torchvision.datasets.CIFAR10(./data, trainFalse, transformtransforms.ToTensor(), downloadTrue)
print(test数据, test_data)
print(ftest_data数据的长度是{len(test_data)})
print(第一条数据,test_data[0])
test_data DataLoader(datasettest_data, batch_size64, shuffleTrue)
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展示经过各个层的图片数据
class convModel(nn.Module):def __init__(self):super(convModel, self).__init__()self.conv1 nn.Conv2d(in_channels3, out_channels6, stride1, padding0, biasTrue, padding_modezeros, kernel_size3)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], dataformatsNCHW, global_stepbatch_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_stepbatch_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
class maxPoolingModel(nn.Module):def __init__(self):super(maxPoolingModel, self).__init__()self.MaxPool2d nn.MaxPool2d(kernel_size2, stride2, ceil_modeFalse)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], dataformatsNCHW, global_stepbatch_id)input_data, label data[0],data[1]output_data model(input_data)write.add_images(经过池化层之后的图片数据展示, output_data, global_stepbatch_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])
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], dataformatsNCHW, global_stepbatch_id)input_data, label data[0],data[1]output_data model(input_data)write.add_images(经过非线性层之后的图片数据展示, output_data, global_stepbatch_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 完整的模型训练测试流程
class Model(nn.Module):def __init__(self):super(Model,self).__init__()self.model nn.Sequential(nn.Conv2d(in_channels3, out_channels32, kernel_size5, padding2,stride1),nn.MaxPool2d(kernel_size2, stride2),nn.Conv2d(in_channels32, out_channels32, kernel_size5, padding2,stride1),nn.MaxPool2d(kernel_size2, stride2),nn.Conv2d(in_channels32, out_channels64, kernel_size5, padding2,stride1),nn.MaxPool2d(kernel_size2, stride2),nn.Flatten(),nn.Linear(in_features1024, out_features64),nn.Linear(in_features64, out_features10))def forward(self, batch_data):return self.model(batch_data)
# 第一种方式使用cuda只需要给模型、损失函数、训练数据、测试数据调用cuda即可但是这种情况下必须使用if torch.cuda.is_available():判断是否存在cuda没有的话还是使用cpu但是没有使用torch.cuda.is_available()判断的话会出错导致程序无法运行
# 第二种方式cuda0 单个显卡
device torch.device(cuda:0 if torch.cuda.is_available() else cpu)
model Model()
model.to(devicedevice)
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_size2, stride2, padding0, dilation1, ceil_modeFalse) (2): Conv2d(32, 32, kernel_size(5, 5), stride(1, 1), padding(2, 2)) (3): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse) (4): Conv2d(32, 64, kernel_size(5, 5), stride(1, 1), padding(2, 2)) (5): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse) (6): Flatten(start_dim1, end_dim-1) (7): Linear(in_features1024, out_features64, biasTrue) (8): Linear(in_features64, out_features10, biasTrue)
使用Gpu训练的两种方式 # 第一种方式使用cuda只需要给模型、损失函数、训练数据、测试数据调用cuda即可但是这种情况下必须使用if torch.cuda.is_available():判断是否存在cuda没有的话还是使用cpu但是没有使用torch.cuda.is_available()判断的话会出错导致程序无法运行
# 第二种方式cuda0 单个显卡
device torch.device(cuda:0 if torch.cuda.is_available() else cpu)在这种情况写只需要将对应的模型、损失函数、训练数据、测试数据使用to调用device上即可使用tensorboard显示模型
from torch.utils.tensorboard import SummaryWriter
write SummaryWriter(model)
write.add_graph(modelmodel,input_to_modelbatch_data)
write.close()
模型训练测试
# -------------------------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(), lr0.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.0print(---------------------第 {} 轮训练开始---------------------.format(epoch1))model.train()for batch_id, data in enumerate(train_data):input_data, input_label datainput_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 1sum_loss_list.append(ever_epoch_loss_sum)epoch_list.append(epoch)print(---------------------第 {} 轮测试开始---------------------.format(epoch1))model.eval()total_test_loss 0total_accuracy 0with torch.no_grad():for batch_id, data in enumerate(test_data):images, label dataimages 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 accuracyprint(整体测试集上的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 1torch.save(model,model_{}.pth.format(epoch))print(保存第 {} 轮模型.format(epoch1))
write.close()
L1Loss函数
inputs torch.tensor([1,2,3], dtypetorch.float32)
print(原始数据inputs, inputs)
print(原始数据形状inputs.shape, inputs.shape)
targets torch.tensor([1,2,5], dtypetorch.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)
保存未训练模型或者已经训练完的模型
# 模型的保存
torch.save(model,class_model.pth)
# 模型加载但是这种情况下如果加载的模型和原本的模型没有在同一个文件中那么需要将原本的模型使用from加载到当前文件中再使用torch.load
model torch.load(class_model.pth)
print(model)
4 加载训练好的模型进行测试
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_channels3, out_channels32, kernel_size5, padding2,stride1),nn.MaxPool2d(kernel_size2, stride2),nn.Conv2d(in_channels32, out_channels32, kernel_size5, padding2,stride1),nn.MaxPool2d(kernel_size2, stride2),nn.Conv2d(in_channels32, out_channels64, kernel_size5, padding2,stride1),nn.MaxPool2d(kernel_size2, stride2),nn.Flatten(),nn.Linear(in_features1024, out_features64),nn.Linear(in_features64, out_features10))def forward(self, batch_data):return self.model(batch_data)
load_model torch.load(G:\python_files\深度学习代码库\model_49.pth) # 加载模型使用上面的非字典形式保存的模型这个时候加载的时候必须把原本定义的模型加载到当前文件然后使用该函数加载。同时需要注意如果加载的模型原本是在cuda上跑的这个时候要将模型使用load函数的参数map_locationtorch.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_locationtorch.device(cpu)加载到cpu上或者也可以将图片的数据放入到gpu上与原本的模型对应起来 # 因为上面的模型训练的时候输入是(NCHW)所以将训练完的模型加载进来使用测试的时候必须要将一张图片reshape模型需要的形状否则就会报错
tensor_shape torch.reshape(trans_image_tensor,(1,3,32,32)).to(torch.device(cuda:0))
