completar los pasos
Preparar conjunto de datos
Cargador de datos cargar conjunto de datos
Construir modelo de red Crear
instancia de modelo de red
Definir función de pérdida
Definir optimizador
Establecer parámetros de entrenamiento de red
Iniciar entrenamiento
Verificar modelo
Guardar modelo
Visualizar resultados de entrenamiento (completado usando tensorboard)
Introducción al conjunto de datos
CIFAR10 es un conjunto de datos de visión por computadora recopilados por los estudiantes de Hinton Alex Krizhevsky e Ilya Sutskever para el reconocimiento universal de objetos y contiene 60.000 imágenes en color RGB de 32 x 32, un total de 10 categorías. Entre ellas, se utilizan 50.000 imágenes para el conjunto de entrenamiento y 10.000 imágenes para el conjunto de prueba.
Estructura del modelo CIFAR
código completo
Estructura del modelo de red CIFAR10:
# model.py文件
# 搭建CIFAR10神经网络
import torch
from torch import nn
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平
nn.Linear(1024, 64), # 1024=64*4*4
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
# 验证搭建的网络是否正确
if __name__ == '__main__':
tudui = Tudui()
input = torch.ones((64, 3, 32, 32))
output = tudui(input)
print(output.shape)Código de entrenamiento de versión de CPU
# train.py文件
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from model import *
# 准备数据集
# 训练数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset", train=True, download=False,
transform=torchvision.transforms.ToTensor())
# 测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset", train=False, download=False,
transform=torchvision.transforms.ToTensor())
# 观察训练数据集、测试数据集中的图像有多少张
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size)) # 训练数据集的长度为：50000
print("测试数据集的长度为：{}".format(test_data_size)) # 测试数据集的长度为：10000
# 使用dataloader加载数据集
train_dataloader = DataLoader(train_data, batch_size=64) # 训练数据集加载
test_dataloader = DataLoader(test_data, batch_size=64) # 测试数据集加载
# 创建网络模型
tudui = Tudui()
# 创建损失函数
# 分类问题采用交叉熵损失函数
loss_fn = nn.CrossEntropyLoss()
# 设定优化器
learning_rate = 0.01 # 0.01=1e-2
# learning_rate = 1e-2
optimizer = torch.optim.SGD(params=tudui.parameters(), lr=learning_rate)
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter("./CIFAR10_train")
for i in range(epoch):
print("———————第{}轮训练开始——————".format(i+1))
# 训练步骤开始
for data in train_dataloader:
imgs, targets = data
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad() # 梯度清零
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
writer.add_scalar("train_loss", loss.item(), total_train_step)
# 测试步骤
total_test_loss = 0
total_accuracy_num = 0
with torch.no_grad():
for data in test_dataloader:
imgs, targets = data
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
total_test_loss = total_test_loss + loss
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy_num = total_accuracy_num + accuracy
print("整体测试集上的Loss：{}".format(total_test_loss))
print("整体测试集上的正确率：{}".format(total_accuracy_num/test_data_size))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar(("test_accuracy", (total_accuracy_num/test_data_size), total_test_step))
total_test_step = total_test_step + 1
# 保存每轮运行的模型
torch.save(tudui, "tudui_{}.pth".format(i))
print("模型已保存！")
writer.close()
Versión GPU_1
Este método consiste en importar cuda al modelo de red, datos y función de pérdida en la versión de CPU.
Por ejemplo:
para el modelo de red: en la versión de CPU, solo necesitamos tudui = Tudui() al crear una instancia de la red; en la versión GPU_1, necesitamos reescribir tudui = Tudui() a tudui = Tudui al crear una instancia de la red. cuda().
Para datos: en la versión de CPU, los datos que utilizamos en el entrenamiento y las pruebas solo necesitan
para datos en train_dataloader: # 训练
imgs, objetivos =
salidas de datos = tudui(imgs)
para datos en test_dataloader: # 测试
imgs, objetivos =
salidas de datos = tudui(imgs)
Eso es todo; mientras que en la versión GPU_1, es:
para datos en train_dataloader: # 训练
imgs, objetivos = datos
# 使用GPU
imgs = imgs.cuda()
objetivos = objetivos.cuda()
salidas = tudui(imgs)
para datos en test_dataloader: # 测试
imgs, objetivos = datos
# 使用GPU
imgs = imgs.cuda()
objetivos = objetivos.cuda()
salidas = tudui(imgs)
Para la función de pérdida: en la versión de CPU, la función de pérdida que usamos solo necesita
#Crear función de pérdida # El problema de clasificación utiliza la función de pérdida de entropía cruzada loss_fn = nn.CrossEntropyLoss()
Eso es todo; y en la versión GPU_1, están:
#Crear función de pérdida # El problema de clasificación utiliza la función de pérdida de entropía cruzada loss_fn = nn.CrossEntropyLoss() loss_fn = loss_fn.cuda() # Usar GPU
Código de entrenamiento de la versión GPU_1
# train_GPU_1.py文件
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
# 准备数据集
# 训练数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset", train=True, download=False,
transform=torchvision.transforms.ToTensor())
# 测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset", train=False, download=False,
transform=torchvision.transforms.ToTensor())
# 观察训练数据集、测试数据集中的图像有多少张
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size)) # 训练数据集的长度为：50000
print("测试数据集的长度为：{}".format(test_data_size)) # 测试数据集的长度为：10000
# 使用dataloader加载数据集
train_dataloader = DataLoader(train_data, batch_size=64) # 训练数据集加载
test_dataloader = DataLoader(test_data, batch_size=64) # 测试数据集加载
# 创建网络模型
# 搭建CIFAR10神经网络
import torch
from torch import nn
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平
nn.Linear(1024, 64), # 1024=64*4*4
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
tudui = Tudui()
tudui = tudui.cuda() # 使用GPU
# 创建损失函数
# 分类问题采用交叉熵损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.cuda() # 使用GPU
# 设定优化器
learning_rate = 0.01 # 0.01=1e-2
# learning_rate = 1e-2
optimizer = torch.optim.SGD(params=tudui.parameters(), lr=learning_rate)
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter("./CIFAR10_train")
for i in range(epoch):
print("———————第{}轮训练开始——————".format(i+1))
# 训练步骤开始
for data in train_dataloader:
imgs, targets = data
# 使用GPU
imgs = imgs.cuda()
targets = targets.cuda()
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad() # 梯度清零
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
writer.add_scalar("train_loss", loss.item(), total_train_step)
# 测试步骤
total_test_loss = 0
total_accuracy_num = 0
with torch.no_grad():
for data in test_dataloader:
imgs, targets = data
# 使用GPU
imgs = imgs.cuda()
targets = targets.cuda()
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
total_test_loss = total_test_loss + loss
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy_num = total_accuracy_num + accuracy
print("整体测试集上的Loss：{}".format(total_test_loss))
test_accuracy = total_accuracy_num/test_data_size # 测试准确率
print("整体测试集上的正确率：{}".format(test_accuracy))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar("test_accuracy", test_accuracy, total_test_step)
total_test_step = total_test_step + 1
# 保存每轮运行的模型
torch.save(tudui, "tudui_{}.pth".format(i))
print("模型已保存！")
writer.close()
Versión GPU_2
Este método consiste en utilizar el método to.(dispositivo) para el modelo de red, los datos y la función de pérdida en la versión de CPU.
Por ejemplo:
primero debemos definir el dispositivo, es decir, dispositivo = torch.device("cpu") (versión de CPU) o dispositivo = torch.device("cuda") (versión de GPU).
Para el modelo de red: en la versión CPU, solo necesitamos crear una instancia de la red con tudui = Tudui(); mientras que en la versión GPU_2, necesitamos reescribir tudui = Tudui() al crear una instancia de la red como
tudui = Tudui() tudui.to(dispositivo)# usar GPU
Para datos: en la versión de CPU, los datos que utilizamos en el entrenamiento y las pruebas solo necesitan
para datos en train_dataloader: # 训练
imgs, objetivos =
salidas de datos = tudui(imgs)
para datos en test_dataloader: # 测试
imgs, objetivos =
salidas de datos = tudui(imgs)
y en la versión GPU_ 2, es:
para datos en train_dataloader: # 训练
imgs, objetivos = datos
# 使用GPU
imgs = imgs.to(dispositivo)
objetivos = objetivos.to(dispositivo)
salidas = tudui(imgs)
para datos en test_dataloader: # 测试
imgs, objetivos = datos
# 使用GPU
imgs = imgs.to(dispositivo)
objetivos = objetivos.to(dispositivo)
salidas = tudui(imgs)
Para la función de pérdida: en la versión de CPU, la función de pérdida que usamos solo necesita
#Crear función de pérdida # El problema de clasificación utiliza la función de pérdida de entropía cruzada loss_fn = nn.CrossEntropyLoss()
Eso es todo; y en la versión GPU_2, están:
# Crear función de pérdida # El problema de clasificación utiliza la función de pérdida de entropía cruzada loss_fn = nn.CrossEntropyLoss() loss_fn.to(device) # Usar GPU
Código de entrenamiento de la versión GPU_2
# train_GPU_2.py文件
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
device = torch.device("cuda") # 定义训练设备
# 准备数据集
# 训练数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset", train=True, download=False,
transform=torchvision.transforms.ToTensor())
# 测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset", train=False, download=False,
transform=torchvision.transforms.ToTensor())
# 观察训练数据集、测试数据集中的图像有多少张
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size)) # 训练数据集的长度为：50000
print("测试数据集的长度为：{}".format(test_data_size)) # 测试数据集的长度为：10000
# 使用dataloader加载数据集
train_dataloader = DataLoader(train_data, batch_size=64) # 训练数据集加载
test_dataloader = DataLoader(test_data, batch_size=64) # 测试数据集加载
# 创建网络模型
# 搭建CIFAR10神经网络
import torch
from torch import nn
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平
nn.Linear(1024, 64), # 1024=64*4*4
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
tudui = Tudui()
tudui.to(device)# 使用GPU
# 创建损失函数
# 分类问题采用交叉熵损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn.to(device) # 使用GPU
# 设定优化器
learning_rate = 0.01 # 0.01=1e-2
# learning_rate = 1e-2
optimizer = torch.optim.SGD(params=tudui.parameters(), lr=learning_rate)
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter("./CIFAR10_train")
for i in range(epoch):
print("———————第{}轮训练开始——————".format(i+1))
# 训练步骤开始
for data in train_dataloader:
imgs, targets = data
# 使用GPU
imgs = imgs.to(device)
targets = targets.to(device)
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad() # 梯度清零
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
writer.add_scalar("train_loss", loss.item(), total_train_step)
# 测试步骤
total_test_loss = 0
total_accuracy_num = 0
with torch.no_grad():
for data in test_dataloader:
imgs, targets = data
# 使用GPU
imgs = imgs.to(device)
targets = targets.to(device)
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
total_test_loss = total_test_loss + loss
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy_num = total_accuracy_num + accuracy
print("整体测试集上的Loss：{}".format(total_test_loss))
test_accuracy = total_accuracy_num/test_data_size # 测试准确率
print("整体测试集上的正确率：{}".format(test_accuracy))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar("test_accuracy", test_accuracy, total_test_step)
total_test_step = total_test_step + 1
# 保存每轮运行的模型
torch.save(tudui, "tudui_{}.pth".format(i))
print("模型已保存！")
writer.close()
Visualización de resultados basada en tensorboard.
Usamos el código de la versión GPU (los modos 1 y 2 están disponibles) para completar el proceso de entrenamiento de visualización del tensorboard y los resultados de las pruebas.
Ejecute el código y obtendrá una carpeta CIFAR10_train en la carpeta del proyecto.
¡Crédito a este código! ! escritor = ResumenWriter("./CIFAR10_train")
Ejecute el comando en Terminal: tensorboard --logdir=CIFAR10_train, obtenga la siguiente URL: http://localhost:6006/, abra la URL.
Obtenga el resultado de la visualización, como se muestra en la siguiente figura.
Obtenga la pérdida de entrenamiento del modelo de red.
¡Los resultados anteriores son los resultados de 10 rondas de entrenamiento modelo!
Predecir el combate real
Probemos el modelo entrenado en imágenes aleatorias para ver cómo funciona.
Entrenamos la red en el conjunto de datos de entrenamiento durante 30 rondas y descubrimos que el modelo entrenado en la ronda 30 era mejor y la tasa de corrección del modelo en el conjunto de prueba alcanzó el 64,56%, por lo que utilizamos el modelo en la ronda 30. para verificar imágenes aleatorias.
Seleccionamos al azar una imagen de un perro, una imagen de un avión y una imagen de un gato de Internet, como se muestra en la siguiente figura.
Guarde estas tres imágenes en la carpeta de imágenes de la carpeta del proyecto, como se muestra en la imagen a continuación.
Muestre estas tres imágenes en pycharm.
Diez etiquetas de verdad fundamental de categoría.
Verificar el código del perro
import torch
import torchvision.transforms
from PIL import Image
from torch import nn
img_path = "./images/dog.png" # .表示当前目录
image = Image.open(img_path)
# print(image) # <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=405x303 at 0x2834CC62F48>
image = image.convert("RGB") # 该代码的作用：
# 因为png格式的图片是四个通道，除了RGB三通道外，还有一个透明度通道。
# 所以我们调用image = image.convert("RGB")，保留其颜色通道。
# print(image) # <PIL.Image.Image image mode=RGB size=405x303 at 0x2834CD7AB88>
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
torchvision.transforms.ToTensor()])
image = transform(image)
# print(image.size)
# CIFAR10网络模型结构
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平
nn.Linear(1024, 64), # 1024=64*4*4
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
# 加载网络模型参数
model = torch.load("tudui_29.pth", map_location=torch.device("cpu"))
# map_location=torch.device("cpu") 将GPU版本的模型对应到CPU上
# print(model)
image = torch.reshape(image, (1, 3, 32, 32))
model.eval()
with torch.no_grad():
output = model(image)
print(output) # tensor([[ -3.3239, -5.6744, 5.5848, 3.1388, 4.8541, 13.1417, -3.0066, 4.5897, -14.3501, -7.2900]])
print(output.argmax(1)) # tensor([5]) 标签5对应的是狗
¡Verificación exitosa!
Verificar el código del avión.
import torch
import torchvision.transforms
from PIL import Image
from torch import nn
img_path = "./images/plane.png" # .表示当前目录
image = Image.open(img_path)
# print(image) # <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=405x303 at 0x2834CC62F48>
image = image.convert("RGB") # 该代码的作用：
# 因为png格式的图片是四个通道，除了RGB三通道外，还有一个透明度通道。
# 所以我们调用image = image.convert("RGB")，保留其颜色通道。
# print(image) # <PIL.Image.Image image mode=RGB size=405x303 at 0x2834CD7AB88>
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
torchvision.transforms.ToTensor()])
image = transform(image)
# print(image.size)
# CIFAR10网络模型结构
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平
nn.Linear(1024, 64), # 1024=64*4*4
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
# 加载网络模型参数
model = torch.load("tudui_29.pth", map_location=torch.device("cpu"))
# map_location=torch.device("cpu") 将GPU版本的模型对应到CPU上
# print(model)
image = torch.reshape(image, (1, 3, 32, 32))
model.eval()
with torch.no_grad():
output = model(image)
print(output) # tensor([[10.6781, -2.0109, 4.5609, 1.3858, -1.3748, -1.3599, 3.4883, -7.2311, -3.5088, -3.3030]])
print(output.argmax(1)) # tensor([0]) 标签0对应的是飞机
¡La verificación fue exitosa!
Verificar el código del gato.
import torch
import torchvision.transforms
from PIL import Image
from torch import nn
img_path = "./images/cat.png" # .表示当前目录
image = Image.open(img_path)
# print(image) # <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=405x303 at 0x2834CC62F48>
image = image.convert("RGB") # 该代码的作用：
# 因为png格式的图片是四个通道，除了RGB三通道外，还有一个透明度通道。
# 所以我们调用image = image.convert("RGB")，保留其颜色通道。
# print(image) # <PIL.Image.Image image mode=RGB size=405x303 at 0x2834CD7AB88>
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
torchvision.transforms.ToTensor()])
image = transform(image)
# print(image.size)
# CIFAR10网络模型结构
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平
nn.Linear(1024, 64), # 1024=64*4*4
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
# 加载网络模型参数
model = torch.load("tudui_29.pth", map_location=torch.device("cpu"))
# map_location=torch.device("cpu") 将GPU版本的模型对应到CPU上
# print(model)
image = torch.reshape(image, (1, 3, 32, 32))
model.eval()
with torch.no_grad():
output = model(image)
print(output) # tensor([[-1.4196, -5.0211, 1.2063, 4.8532, -2.0156, 2.7169, 0.4598, 0.5168, -0.3567, -0.8418]])
print(output.argmax(1)) # tensor([3]) 标签3对应的是猫
¡La verificación fue exitosa!
Aunque la tasa de corrección del modelo entrenado durante 30 rondas en el conjunto de prueba es solo del 64,56%, podemos ver mediante verificación aleatoria que el efecto del modelo sigue siendo muy bueno. Solo verificamos tres imágenes, por supuesto, también podemos verificar más imágenes.