Notas de estudio de combate de red neuronal de Pytorch_17 Introducción a la red neuronal convolucional profunda + operación de agrupación + combate de red neuronal convolucional profunda

1 Descripción general de las redes neuronales convolucionales profundas

1.1 Diagrama de estructura del modelo de red neuronal convolucional profunda

1.1.1 Análisis de la estructura directa de la red neuronal convolucional profunda

• En la capa de entrada, cada píxel se introduce en la red como un nodo de características.
• Capa convolucional: compuesta por múltiples filtros.
• Capa de agrupación: reduzca la dimensionalidad del resultado de la convolución y realice el procesamiento de reducción de la dimensionalidad en el mapa de características después de la convolución para obtener características más significativas. Sobre la base de las características originales del gráfico, se reduce la cantidad de operaciones posteriores.
• Capa de agrupación de promedio global: Tome el promedio global de los mapas de características generados, esta capa puede ser reemplazada por una red completamente conectada.
• Capa de salida: La red necesita dividir los datos en varias categorías, esta capa tiene varios nodos de salida, cada nodo de salida representa la probabilidad de pertenecer a la muestra actual de ese tipo.

1.2 Pasos de la retropropagación de redes neuronales convolucionales

(1) Pase el error a la capa anterior. Cuando se realiza la derivación inversa de la operación de convolución, el mapa de características generado debe rellenarse una vez, y luego se realiza una operación de convolución con el núcleo de convolución transpuesto para obtener la belleza incorrecta de el extremo de entrada, y se realiza la transmisión inversa del error.
(2) Calcule el valor de la diferencia que debe actualizarse de acuerdo con la expresión del parámetro de aprendizaje correspondiente al error actual, que es la misma que la derivación inversa en la red totalmente conectada. La regla de la cadena todavía se usa para encontrar y minimizar el error. El grado horizontal de , y luego con la tasa de aprendizaje para calcular la diferencia actualizada.

2 Operación de agrupación

2.1 Descripción general de la operación de agrupación

2.1.1 El papel de las operaciones de agrupación

El objetivo principal de la reducción de la dimensionalidad es minimizar el tamaño de la matriz manteniendo las características originales.

2.1.2 Comparación de agrupación y convolución

Agrupación: solo se preocupa por el tamaño del filtro, principalmente toma el valor promedio o máximo de los píxeles en el área de mapeo del filtro.

Convolución: El producto de los píxeles en las posiciones correspondientes.

2.2 Clasificación de las operaciones de agrupación

2.2.1 Combinación de medias

En el área correspondiente al tamaño del filtro en la imagen, se toma el valor promedio de todos sus píxeles, que es más sensible a la información de fondo.

2.2.2 Agrupación máxima

El área correspondiente al tamaño del filtro en la imagen toma el valor máximo para todos sus píxeles, que es más sensible a las características de la textura.

2.2 Interfaz de la función de agrupación

2.2.1 Función de agrupación promedio
nn.AvgPool2d: operación de agrupación promedio bidimensional https://blog.csdn.net/qq_50001789/article/details/120537858

torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None)

• kernel_size: el tamaño del kernel de agrupación
• zancada: la zancada en movimiento de la ventana, el valor predeterminado es el mismo tamaño que kernel_size
• relleno: tamaño de ancho de relleno cero en ambos lados
• ceil_mode: cuando se establece en True, la operación de redondeo se usa en el proceso de cálculo de la forma de salida; de lo contrario, se usa la operación de redondeo
• count_include_pad: booleano, cuando es verdadero, el relleno cero se incluirá en el cálculo de la agrupación promedio; de lo contrario, el relleno cero no se incluirá
• divisor_override: si se especifica, el divisor será reemplazado por divisor_override. En otras palabras, si no se especifica esta variable, el proceso de cálculo de la agrupación promedio es en realidad en un núcleo de agrupación, sumando los elementos y dividiendo por el tamaño del núcleo de agrupación, es decir, divisor_override por defecto es la altura del núcleo de agrupación × de ancho; si se especifica esta variable, el proceso de agrupación es la suma de los elementos en el kernel agrupado y dividido por divisor_override.

2.2.2 Función de agrupación máxima

class torch.nn.MaxPool1d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

• kernel_size (int o tuple): tamaño de la ventana para la agrupación máxima
• zancada (int o tupla, opcional): la zancada del movimiento de la ventana para la agrupación máxima. El valor predeterminado es kernel_size
• relleno (int o tupla, opcional): la cantidad de capas para agregar 0 a cada borde de la entrada
• dilatación (int o tupla, opcional): un parámetro que controla el paso de los elementos en la ventana
• return_indices: si es igual a True, devolverá el índice del valor máximo de salida, lo que es útil para las operaciones de muestreo superior
• ceil_mode: si es igual a True, al calcular el tamaño de la señal de salida, utilizará el redondeo hacia arriba en lugar de la operación de redondeo hacia abajo predeterminada

torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

• kernel_size (int o tuple): tamaño de la ventana para la agrupación máxima
• zancada (int o tupla, opcional): la zancada del movimiento de la ventana para la agrupación máxima. El valor predeterminado es kernel_size
• relleno (int o tupla, opcional): la cantidad de capas para agregar 0 a cada borde de la entrada
• dilatación (int o tupla, opcional): un parámetro que controla el paso de los elementos en la ventana
• return_indices: si es igual a True, devolverá el índice del valor máximo de salida, lo que es útil para las operaciones de muestreo superior
• ceil_mode: si es igual a True, al calcular el tamaño de la señal de salida, utilizará el redondeo hacia arriba en lugar de la operación de redondeo hacia abajo predeterminada

2.3 El combate real de la función de agrupación

2.3.1 Definición de variables de entrada --- pool2d.py (Parte 1)

import torch

### 1.1 定义输入变量
img = torch.tensor([
    [[0.0,0.0,0.0,0.0],[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0]],
    [[4.0,4.0,4.0,4.0],[5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0],[7.0,7.0,7.0,7.0]]
]).reshape([1,2,4,4]) # 定义张量，模拟输入图像
print(img) # 输出结果
print(img[0][0]) # 输出第1通道的内容

# Salida:
# tensor ([[0, 0, 0, 0],
# [1, 1, 1, 1],
# [2, 2, 2, 2],
# [3, 3, 3, 3]] )
print(img[0][1]) # salida del contenido del canal 2
# salida:
# tensor([[4, 4, 4, 4],
# [5, 5, 5, 5],
# [6, 6, 6, 6],
# [7, 7, 7, 7]])

2.3.2 Definición de operaciones de agrupación y computación --- pool2d.py (Parte 2)

### 定义池化操作
pooling = torch.nn.functional.max_pool2d(img,kernel_size=2)
print("pooling :",pooling) # 输出最大池化结果(池化区域为2，步长为2)，

pooling1 = torch.nn.functional.max_pool2d(img,kernel_size=2,stride=1) # 不补0
print("pooling1 :",pooling1) #  不补0，输出最大池化结果(池化区域为2X2，步长为1)，生成3X3的矩阵

pooling2 = torch.nn.functional.avg_pool2d(img,kernel_size=2,stride=1,padding=1)# 先执行补0，再进行池化
print("pooling2 :",pooling2) # 先执行补0，输出平均池化结果(池化区域为4X4，步长为1)，生成3X3的矩阵

# 全局池化操作，使用一个与原来输入相同尺寸的池化区域来进行池化操作，一般在最后一层用于图像表达
pooling3 = torch.nn.functional.avg_pool2d(img,kernel_size=4)
print("pooling3 :",pooling3) # 输出平均池化结果(池化区域为4，步长为4)

# 对于输入的张量计算两次均值，可得平均池化结果
m1 = img.mean(3)
print("第1次均值结果",m1)
print("第2次均值结果",m1.mean(2))
### 对于输入数据进行两次平均值操作时，可以看到在输入数据进行两次平均值计算的结果与pooling3的数值是一直的，即为等价

agrupación : tensor([[[[1., 1.],
          [3., 3.]],

         [[5., 5.],
          [7., 7.]]]])
pooling1 : tensor([[[[1., 1., 1.],
          [2., 2., 2.],
          [ 3., 3., 3.]],

         [[5., 5., 5.],
          [6., 6., 6.],
          [7., 7., 7.]]]])
pooling2 : tensor([[[[0.0000, 0.0000, 0.0000 , 0.0000, 0.0000],
          [0.2500, 0.5000, 0.5000, 0.5000, 0.2500],
          [0.7500, 1.5000, 1.5000, 1.5000, 0.7500],
          [1.2500, 2.5000, 2.5000, 2.5000, 1.2500],
          [0.7500, 1.5000, 1.5000, 1.5000 , 0,7500]],

         [[1.0000, 2.0000, 2.0000],
          [2.2500, 4.5000], [2.7500, 5.5000],
          [2.7500, 5.7500],
          [3.2500, 6.5000, 6.5000, 6.5000, 3.2500],
          [1.7500, 3.5000, 3.5000, 3.5000, 1.7500] ]]])
pooling3 : tensor([[[[1.5000]], [[5.5000]]]])
1er resultado medio tensor([[[0., 1., 2., 3.],
         [4., 5 ., 6., 7.]]])
2º resultado medio tensor([[1.5000, 5.5000]])

2.3.3 Descripción general del código --- pool2d.py

import torch

### 1.1 定义输入变量
img = torch.tensor([
    [[0.0,0.0,0.0,0.0],[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0]],
    [[4.0,4.0,4.0,4.0],[5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0],[7.0,7.0,7.0,7.0]]
]).reshape([1,2,4,4]) # 定义张量，模拟输入图像
print(img) # 输出结果
print(img[0][0]) # 输出第1通道的内容
# 输出：
# tensor([[0, 0, 0, 0],
#         [1, 1, 1, 1],
#         [2, 2, 2, 2],
#         [3, 3, 3, 3]])
print(img[0][1]) # 输出第2通道的内容
# 输出：
# tensor([[4, 4, 4, 4],
#         [5, 5, 5, 5],
#         [6, 6, 6, 6],
#         [7, 7, 7, 7]])

### 定义池化操作
pooling = torch.nn.functional.max_pool2d(img,kernel_size=2)
print("pooling :",pooling) # 输出最大池化结果(池化区域为2，步长为2)，

pooling1 = torch.nn.functional.max_pool2d(img,kernel_size=2,stride=1) # 不补0
print("pooling1 :",pooling1) #  不补0，输出最大池化结果(池化区域为2X2，步长为1)，生成3X3的矩阵

pooling2 = torch.nn.functional.avg_pool2d(img,kernel_size=2,stride=1,padding=1)# 先执行补0，再进行池化
print("pooling2 :",pooling2) # 先执行补0，输出平均池化结果(池化区域为4X4，步长为1)，生成3X3的矩阵

# 全局池化操作，使用一个与原来输入相同尺寸的池化区域来进行池化操作，一般在最后一层用于图像表达
pooling3 = torch.nn.functional.avg_pool2d(img,kernel_size=4)
print("pooling3 :",pooling3) # 输出平均池化结果(池化区域为4，步长为4)

# 对于输入的张量计算两次均值，可得平均池化结果
m1 = img.mean(3)
print("第1次均值结果",m1)
print("第2次均值结果",m1.mean(2))
### 对于输入数据进行两次平均值操作时，可以看到在输入数据进行两次平均值计算的结果与pooling3的数值是一直的，即为等价

3 redes neuronales convolucionales profundas en acción