Experimento 6 La red neuronal convolucional (5) utiliza resnet18 previamente entrenado para implementar la clasificación CIFAR-10

5.5 Práctica: completar tareas de clasificación de imágenes basadas en la red ResNet18

En esta práctica, practicamos una tarea de clasificación de imágenes más general.

La clasificación de imágenes es una tarea básica en visión por computadora, que divide diferentes imágenes en diferentes categorías según la semántica de la imagen. Muchas tareas también se pueden convertir en tareas de clasificación de imágenes. Por ejemplo, la detección de rostros consiste en determinar si hay un rostro en un área, lo que puede considerarse como una tarea de clasificación de imágenes de dos clases.

Aquí, utilizamos el conjunto de datos clásico en el campo de la visión por computadora: conjunto de datos CIFAR-10, la red es el modelo ResNet18, la función de pérdida es la pérdida de entropía cruzada, el optimizador es el optimizador Adam y el índice de evaluación es la precisión. .

5.5.1 Procesamiento de datos

5.5.1.1 Introducción a los conjuntos de datos

El conjunto de datos CIFAR-10 contiene 10 categorías diferentes y un total de 60.000 imágenes, de las cuales hay 6.000 imágenes en cada categoría y el tamaño de la imagen es 32 × 32 píxeles. En la Figura 5.15 se muestra un ejemplo del conjunto de datos CIFAR-10.

5.5.1.2 Lectura de datos

El conjunto de datos cifar-10 consta de 60.000 imágenes en color con una resolución de 32x32, divididas en 10 categorías, cada categoría contiene 6.000 imágenes y el conjunto de datos cifar-10 tiene 50.000 imágenes de entrenamiento y 10.000 imágenes de prueba.
El conjunto de datos final se compone de:

• Conjunto de entrenamiento: 50.000 muestras.
• Conjunto de validación: 10.000 muestras.
• Conjunto de prueba: 10.000 muestras.
  El código para leer un lote de datos es el siguiente:

import torch
from torchvision.transforms import transforms
import torchvision
from torch.utils.data import DataLoader
 
transformer=transforms.Compose([transforms.ToTensor(),
                               transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])])
 
trainset = torchvision.datasets.CIFAR10(root='./cifar10', train=True, download=True, transform=transformer)
devset=torchvision.datasets.CIFAR10(root='./cifar10',train=False,download=True,transform=transformer)
testset=torchvision.datasets.CIFAR10(root='./cifar10',train=False,download=True,transform=transformer)
 
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

Observe visualmente una de las imágenes de muestra y la etiqueta correspondiente, el código es el siguiente:

image,label=trainset[0]
print(image.size())
image, label = np.array(image), int(label)
plt.imshow(image.transpose(1,2,0))
plt.show()
 
print(classes[label])

resultado de la operación:

torch.Size([3, 32, 32])
frog

5.5.2 Construcción del modelo

Los experimentos de clasificación de imágenes se realizaron utilizando Resnet18 en la API de torchvision.

from torchvision.models import resnet18
 
resnet18_model = resnet18(pretrained=True)

Pytorch proporciona la interfaz torchvision.models, que contiene algunas estructuras de red de uso común y proporciona modelos previamente entrenados, que se pueden leer mediante llamadas simples.

1. ¿Qué es un "modelo previamente entrenado"? ¿Qué es el "aprendizaje por transferencia"?

Modelo previamente entrenado

Los modelos previamente entrenados son arquitecturas de aprendizaje profundo que han sido entrenadas para realizar una tarea específica en grandes cantidades de datos (por ejemplo, identificar problemas de clasificación en imágenes). Este tipo de capacitación no es fácil de realizar y, a menudo, requiere muchos recursos, más allá de lo que muchas personas pueden hacer con modelos de aprendizaje profundo, y no tengo una GPU de lote grande. Cuando hablamos de modelos previamente entrenados, generalmente nos referimos a CNN entrenadas en Imagenet (una arquitectura utilizada para tareas relacionadas con la visión). El conjunto de datos de ImageNet contiene más de 14 millones de imágenes, con 1,2 millones de imágenes divididas en 1000 categorías (aproximadamente 1 millón de imágenes con cuadros delimitadores y anotaciones).

transferir aprendizaje

El aprendizaje por transferencia es una tecnología de aprendizaje automático que, como su nombre indica, se refiere a la capacidad de transferir conocimientos de un campo a otro.
Sabemos que las redes neuronales necesitan entrenarse con datos: obtienen información de los datos y los convierten en los pesos correspondientes. Estos pesos se pueden extraer y transferir a otras redes neuronales. Al "transferir" estas características aprendidas, no necesitamos entrenar una red neuronal desde cero.

¿Por qué necesitamos entrenar previamente el modelo?

En primer lugar, el modelo de preentrenamiento es una aplicación de aprendizaje por transferencia, que utiliza texto casi ilimitado para aprender representaciones sensibles al contexto de cada miembro de la oración de entrada, e implícitamente aprende conocimientos gramaticales y semánticos generales.
En segundo lugar, puede transferir el conocimiento aprendido del dominio abierto a tareas posteriores para mejorar las tareas de bajos recursos, lo que también es muy beneficioso para el procesamiento del lenguaje de bajos recursos.
En tercer lugar, los modelos previamente entrenados han logrado resultados de última generación en casi todas las tareas de PNL.
Finalmente, este modelo de preentrenamiento + mecanismo de ajuste fino tiene buena escalabilidad. Al admitir una nueva tarea, solo necesita usar los datos anotados de la tarea para el ajuste fino, lo que pueden lograr ingenieros comunes.

2. Compare los efectos de "usar un modelo previamente entrenado" y "no usar un modelo previamente entrenado".

resnet = models.resnet18(pretrained=True)
resnet = models.resnet18(pretrained=False)
notas de estudio de pytorch cargando notas del algoritmo model_AI previamente entrenado blog-CSDN blog_pytorch cargando modelo previamente entrenado

5.5.3 Entrenamiento modelo

Reutilice la clase RunnerV3, cree una instancia de la clase RunnerV3 y pase la configuración de entrenamiento.
Utilice el conjunto de entrenamiento y el conjunto de validación para el entrenamiento de modelos y entrene durante un total de 30 épocas.
En los experimentos, el modelo con mayor precisión se guarda como el mejor modelo. El código se implementa de la siguiente manera:

import torch.nn.functional as F
import torch.optim as opt
from Runner import RunnerV3
from metric import Accuracy
 
#指定运行设备
torch.cuda.set_device('cuda:0')
 
# 学习率大小
lr = 0.001
# 批次大小
batch_size = 64
# 加载数据
train_loader = DataLoader(trainset, batch_size=batch_size, shuffle=True)
dev_loader = DataLoader(devset, batch_size=batch_size)
test_loader = DataLoader(testset, batch_size=batch_size)
# 定义网络
model = resnet18_model
# 定义优化器，这里使用Adam优化器以及l2正则化策略，相关内容在7.3.3.2和7.6.2中会进行详细介绍
optimizer = opt.Adam(lr=lr, params=model.parameters(), weight_decay=0.005)
# 定义损失函数
loss_fn = F.cross_entropy
# 定义评价指标
metric = Accuracy(is_logist=True)
# 实例化RunnerV3
runner = RunnerV3(model, optimizer, loss_fn, metric)
# 启动训练
log_steps = 3000
eval_steps = 3000
runner.train(train_loader, dev_loader, num_epochs=30, log_steps=log_steps,
             eval_steps=eval_steps, save_path="best_model.pdparams")

resultado de la operación:

[Train] epoch: 0/30, step: 0/23460, loss: 14.40919
[Train] epoch: 3/30, step: 3000/23460, loss: 0.77919
[Evaluate]  dev score: 0.69040, dev loss: 0.92100
[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.69040
[Train] epoch: 7/30, step: 6000/23460, loss: 0.64090
[Evaluate]  dev score: 0.72860, dev loss: 0.83435
[Evaluate] best accuracy performence has been updated: 0.69040 --> 0.72860
[Train] epoch: 11/30, step: 9000/23460, loss: 0.72482
[Evaluate]  dev score: 0.73170, dev loss: 0.80458
[Evaluate] best accuracy performence has been updated: 0.72860 --> 0.73170[Train] epoch: 15/30, step: 12000/23460, loss: 0.76655
[Evaluate]  dev score: 0.72200, dev loss: 0.83292
[Train] epoch: 19/30, step: 15000/23460, loss: 0.44270[Evaluate]  dev score: 0.74660, dev loss: 0.77437
[Evaluate] best accuracy performence has been updated: 0.73170 --> 0.74660
[Train] epoch: 23/30, step: 18000/23460, loss: 0.60689
[Evaluate]  dev score: 0.73190, dev loss: 0.79955
[Train] epoch: 26/30, step: 21000/23460, loss: 0.64202
[Evaluate]  dev score: 0.75310, dev loss: 0.74181
[Evaluate] best accuracy performence has been updated: 0.74660 --> 0.75310
[Evaluate]  dev score: 0.71180, dev loss: 0.88972
[Train] Training done!

Bueno, este modelo tardó mucho. . . Tal vez sea un poco complicado

5.5.4 Evaluación del modelo

Utilice los datos de prueba para evaluar el mejor modelo guardado durante el proceso de capacitación y observe la precisión y la pérdida del modelo en el conjunto de prueba. El código se implementa de la siguiente manera:

# 加载最优模型
runner.load_model('best_model.pdparams')
# 模型评价
score, loss = runner.evaluate(test_loader)
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))

resultado de la operación:

[Test] accuracy/loss: 0.7270/1.8212

5.5.5 Predicción del modelo

De manera similar, también puede usar el modelo guardado para realizar predicciones del modelo en los datos en el conjunto de prueba y observar el efecto del modelo. La implementación del código específico es la siguiente:

#获取测试集中的一个batch的数据
for X, label in test_loader:
 
    logits = runner.predict(X)
    #多分类，使用softmax计算预测概率
    pred = F.softmax(logits)
    #获取概率最大的类别
    pred_class = torch.argmax(pred[2]).numpy()
    label = label[2].data.numpy()
    #输出真实类别与预测类别
    print("The true category is {} and the predicted category is {}".format(classes[label], classes[pred_class]))
    #可视化图片
    X=np.array(X)
    X=X[1]
    plt.imshow(X.transpose(1, 2, 0))
    plt.show()
    break

resultado de la operación:

The true category is 8 and the predicted category is 8

Evalúe brevemente con sus propias palabras: LeNet, AlexNet, VGG, GoogLeNet, ResNet

El
modelo de reconocimiento de dígitos escritos a mano de LeNet es una red neuronal convolucional comercial muy conocida que en ese momento la mayoría de los bancos de Estados Unidos la utilizaban para reconocer dígitos escritos a mano en cheques. La estructura original de Lenet-5 se muestra en la siguiente figura, que incluye: capa convolucional, reducción de resolución, capa convolucional, reducción de resolución, capa convolucional (para lograr una conexión completa), capa completamente conectada y capa de conexión gaussiana (para clasificación).

Características de LeNet:

(1) Cada capa convolucional contiene tres partes: convolución, agrupación y función de activación no lineal
(2) Utilice la convolución para extraer características espaciales
(3) Capa de agrupación promedio de reducción de resolución (submuestra)
(4) Tangente hiperbólica (Tanh) o sigmoide (Sigmoide) la función de activación
MLP se utiliza como clasificador final
(5) Las conexiones escasas entre capas reducen la complejidad computacional

alexnet

AlexNet, que esencialmente extiende la profundidad de LeNet y aplica algunas técnicas como ReLU y Dropout. AlexNet tiene 5 capas convolucionales y 3 capas de agrupación máxima, que se pueden dividir en dos ramas idénticas, la superior y la inferior, y las dos ramas pueden intercambiar información entre sí en la tercera capa convolucional y la capa completamente conectada. Una red excelente propuesta el mismo año que Inception es VGG-Net, que tiene núcleos de convolución más pequeños y capas más profundas que AlexNet.

AlexNet utiliza dos entrenamientos de GPU para mejorar la velocidad y utiliza el entrenamiento de GPU. A diferencia de las CPU, las GPU están diseñadas para realizar cálculos matemáticos y geométricos complejos. AlexNet utiliza 2 GPU para aumentar la velocidad, colocando la mitad de los núcleos de convolución respectivamente. Y use Dropout para evitar el sobreajuste,

Vggnet

El rendimiento de generalización de VGG es muy bueno y, a menudo, se utiliza para la extracción de características de imágenes, la generación de cuadros candidatos para la detección de objetivos, etc. El mayor problema con VGG es la cantidad de parámetros. VGG-19 es básicamente la arquitectura de red convolucional con la mayor cantidad de parámetros. Este problema también es el foco de GoogLeNet, que propuso por primera vez la estructura Inception: no utiliza una red completamente conectada tan ampliamente como VGG-Net, por lo que la cantidad de parámetros es muy pequeña.

GoogleLeNet

La característica más importante de GoogLeNet es el uso del módulo Inception, cuyo propósito es diseñar una red con una topología local excelente, es decir, realizar múltiples operaciones de convolución u operaciones de agrupación en paralelo en la imagen de entrada y unir todos los resultados de salida en 1 Mapas de características muy profundos. Debido a que diferentes operaciones de convolución y operaciones de agrupación como 1 1, 3 3 o 5 * 5 pueden obtener información diferente de la imagen de entrada, procesar estas operaciones en paralelo y combinar todos los resultados obtendrá una mejor representación de la imagen .

Resnet

Resnet utiliza una estructura de conexión residual para hacer que la red sea más profunda desde la perspectiva de evitar la desaparición o explosión del gradiente.

La principal innovación es la red residual, de hecho, la propuesta de esta red esencialmente resuelve el problema de no poder entrenar cuando el nivel es relativamente profundo. Este tipo de red, que se basa en la idea de Highway Network, equivale a abrir un canal al lado para que la entrada pueda ir directamente a la salida, y el objetivo de optimización cambia de la salida de ajuste original H (x) a la diferencia entre la salida y la entrada H (x) -x, donde H (X) es la salida de mapeo esperada original de una determinada capa y x es la entrada.

Resumir