ResNet
ResNet también se denomina red residual, que es fácil de optimizar y puede mejorar la precisión al agregar una profundidad considerable. Su bloque residual interno utiliza una conexión de salto, lo que alivia el problema de desaparición de gradiente causado por el aumento de la profundidad en la red profunda. La siguiente es la función residual y el aprendizaje residual.
reSiguiente
ResNeXt es una combinación de ResNet e Inception. ResNeXt propone una estrategia entre la convolución separable en profundidad del kernel de convolución ordinaria: convolución de grupo, mediante el control del número de grupos (cardinalidad) para lograr un equilibrio entre las dos estrategias.
Práctica de guerra de perros y gatos
Primero cree el modelo VGG
model_vgg = models.vgg16(pretrained=True)
with open('./imagenet_class_index.json') as f:
class_dict = json.load(f)
dic_imagenet = [class_dict[str(i)][1] for i in range(len(class_dict))]
inputs_try , labels_try = inputs_try.to(device), labels_try.to(device)
model_vgg = model_vgg.to(device)
outputs_try = model_vgg(inputs_try)
print(outputs_try)
print(outputs_try.shape)
'''
可以看到结果为5行，1000列的数据，每一列代表对每一种目标识别的结果。
但是我也可以观察到，结果非常奇葩，有负数，有正数，
为了将VGG网络输出的结果转化为对每一类的预测概率，我们把结果输入到 Softmax 函数
'''
m_softm = nn.Softmax(dim=1)
probs = m_softm(outputs_try)
vals_try,pred_try = torch.max(probs,dim=1)
print( 'prob sum: ', torch.sum(probs,1))
print( 'vals_try: ', vals_try)
print( 'pred_try: ', pred_try)
print([dic_imagenet[i] for i in pred_try.data])
imshow(torchvision.utils.make_grid(inputs_try.data.cpu()),
title=[dset_classes[x] for x in labels_try.data.cpu()])
Modifique la última capa y congele los parámetros de la capa anterior.
El modelo VGG se muestra en la siguiente figura. Tenga en cuenta que la red consta de tres elementos:
- La capa de convolución (CONV) es para encontrar el patrón local en la imagen
- La capa totalmente conectada (FC) es establecer la asociación de características globalmente
- Pooling (Pool) es reducir la dimensión de la imagen para mejorar la invariancia de la característica
Nuestro objetivo de VGG es usar el modelo preentrenado, por lo que debemos reemplazar la última capa nn.Linear de 1000 clases a 2 clases. Para congelar los parámetros de las capas anteriores durante el entrenamiento, debe configurar require_grad=False. De esta forma, al propagar hacia atrás el gradiente de entrenamiento, los pesos de las capas anteriores no se actualizarán automáticamente. Durante el entrenamiento, solo se actualizan los parámetros de la última capa.
print(model_vgg)
model_vgg_new = model_vgg;
for param in model_vgg_new.parameters():
param.requires_grad = False
model_vgg_new.classifier._modules['6'] = nn.Linear(4096, 2)
model_vgg_new.classifier._modules['7'] = torch.nn.LogSoftmax(dim = 1)
model_vgg_new = model_vgg_new.to(device)
print(model_vgg_new.classifier)
Entrenar y probar la capa completamente conectada incluye tres pasos: Paso 1, crear una función de pérdida y un optimizador; Paso 2, entrenar el modelo; Paso 3, probar el modelo.
'''
第一步：创建损失函数和优化器
损失函数 NLLLoss() 的 输入 是一个对数概率向量和一个目标标签.
它不会为我们计算对数概率，适合最后一层是log_softmax()的网络.
'''
criterion = nn.NLLLoss()
# 学习率
lr = 0.001
# 随机梯度下降
optimizer_vgg = torch.optim.SGD(model_vgg_new.classifier[6].parameters(),lr = lr)
'''
第二步：训练模型
'''
def train_model(model,dataloader,size,epochs=1,optimizer=None):
model.train()
for epoch in range(epochs):
running_loss = 0.0
running_corrects = 0
count = 0
for inputs,classes in dataloader:
inputs = inputs.to(device)
classes = classes.to(device)
outputs = model(inputs)
loss = criterion(outputs,classes)
optimizer = optimizer
optimizer.zero_grad()
loss.backward()
optimizer.step()
_,preds = torch.max(outputs.data,1)
# statistics
running_loss += loss.data.item()
running_corrects += torch.sum(preds == classes.data)
count += len(inputs)
print('Training: No. ', count, ' process ... total: ', size)
epoch_loss = running_loss / size
epoch_acc = running_corrects.data.item() / size
print('Loss: {:.4f} Acc: {:.4f}'.format(
epoch_loss, epoch_acc))
# 模型训练
train_model(model_vgg_new,loader_train,size=dset_sizes['train'], epochs=1,
optimizer=optimizer_vgg)
def test_model(model,dataloader,size):
model.eval()
predictions = np.zeros(size)
all_classes = np.zeros(size)
all_proba = np.zeros((size,2))
i = 0
running_loss = 0.0
running_corrects = 0
for inputs,classes in dataloader:
inputs = inputs.to(device)
classes = classes.to(device)
outputs = model(inputs)
loss = criterion(outputs,classes)
_,preds = torch.max(outputs.data,1)
# statistics
running_loss += loss.data.item()
running_corrects += torch.sum(preds == classes.data)
predictions[i:i+len(classes)] = preds.to('cpu').numpy()
all_classes[i:i+len(classes)] = classes.to('cpu').numpy()
all_proba[i:i+len(classes),:] = outputs.data.to('cpu').numpy()
i += len(classes)
print('Testing: No. ', i, ' process ... total: ', size)
epoch_loss = running_loss / size
epoch_acc = running_corrects.data.item() / size
print('Loss: {:.4f} Acc: {:.4f}'.format(
epoch_loss, epoch_acc))
return predictions, all_proba, all_classes
predictions, all_proba, all_classes = test_model(model_vgg_new,loader_valid,size=dset_sizes['valid'])
Finalmente, los resultados de predicción del modelo visual (análisis subjetivo)
el análisis subjetivo es generar los resultados predichos y las imágenes de prueba correspondientes. Generalmente, hay cuatro formas:
Ver aleatoriamente algunas imágenes correctas predichas
Ver aleatoriamente algunas imágenes incorrectas predichas
La predicción es correcta, y una imagen con una gran probabilidad
El error de predicción y una imagen con una gran probabilidad
La imagen más incierta, por ejemplo, una imagen con una probabilidad de predicción cercana a 0,5
# 单次可视化显示的图片个数
n_view = 8
correct = np.where(predictions==all_classes)[0]
from numpy.random import random, permutation
idx = permutation(correct)[:n_view]
print('random correct idx: ', idx)
loader_correct = torch.utils.data.DataLoader([dsets['valid'][x] for x in idx],
batch_size = n_view,shuffle=True)
for data in loader_correct:
inputs_cor,labels_cor = data
# Make a grid from batch
out = torchvision.utils.make_grid(inputs_cor)
imshow(out, title=[l.item() for l in labels_cor])
# 类似的思路，可以显示错误分类的图片，这里不再重复代码
resumen
1. ¿El principio básico del aprendizaje residual?
残差在数理统计中是指实际观察值于估计值（拟合值）之间的差。
残差网络的思想就是将网络学习的映射从X到Y转为学习从X到Y-X的差，
然后把学习到的残差信息加到原来的输出上即可。
2. El principio de Normalización por Lotes, pensando en las principales diferencias entre BN, LN e IN.
Batch Normailization（批归一化）是深度学习中非常重要的一个概念，它是一种优化深度神经网络训练的技术，可以加速训练过程，提高模型的准确性。
Batch Normailization的原理是在进行深度神经网络的训练时，每一层的输入都会受到上一层输出的影响而发生变化，使得输入的均值和方差发生变化。
这样，每一层的输出都不再具有稳定性，容易发生梯度消失和梯度爆炸的问题。而BN通过对每个mini-batch的输出进行归一化，使得每一层的输出都具有稳定性，避免上述问题的发生。
具体来说，BN就是在每个mini-batch上对数据进行归一化，将数据按照均值和方差进行标准化，使得数据的均值为0，方差为1.
BN计算均值和标准差时，固定channel（在一个channel内），对HW和batch作平均。
LN计算均值和标准差时，固定batch（在同一个样本内），对HW和channel作平均。
IN计算均值和标准差时，同时固定channel和batch（在同一个样本的一个channel内），对HW作平均。
3. ¿Por qué la convolución de grupo puede mejorar la precisión? Ahora que la convolución de grupo puede mejorar la precisión y reducir la cantidad de cálculo, ¿no puede ser el número de puntajes lo más grande posible?
分组卷积可以减少运算量和参数量，相同输入输出大小的情况下，减少为原来的1/g。
分组卷积可以隔绝不同组的信息交换。
在某些情况下，如每个输出与输入的一部分特征图相关联时，分组卷积可以取得比常规卷积更好的性能，如输出通道为2。但对于需要考虑所有输入特征图信息的情况，分组卷积会降低模型的性能。