Combinación de capas para redes neuronales convolucionales
Las capas convolucionales en una red neuronal convolucional resumen la presencia de características en una imagen de entrada.
Un problema con los mapas de características de salida es que son sensibles a la ubicación de las características en la entrada. Un enfoque para abordar esta sensibilidad es muestrear los mapas de características.
Esto tiene el efecto de hacer que los mapas de características de la muestra hacia abajo resultantes sean más robustos a los cambios en la posición de la entidad en la imagen, a la que se hace referencia en la frase técnica “ invarianza de la traducción local “.
una aproximación a los mapas de características de muestreo descendente al resumir la presencia de características en los parches del mapa de características. Dos métodos comunes de agrupación son la agrupación promedio y la agrupación máxima que resumen la presencia promedio de una característica y la presencia más activada de una característica respectivamente.
En este tutorial, descubrirá cómo funciona la operación de agrupación y cómo implementarla en forma convolucional. Redes neuronales.
Después de completar este tutorial, sabrá:
- La agrupación es necesaria para muestrear la detección de características en los mapas de características.
- Cómo calcular e implementar la agrupación media y máxima en una red neuronal convolucional.
- Cómo utilizar la agrupación global en una red neuronal convolucional.
Comencemos.
Una introducción suave a las capas agrupadas para redes neuronales convolucionales
Foto de Nicholas A. Tonelli algunos derechos reservados.
Descripción general del tutorial
Este tutorial está dividido en cinco partes; son:
- Agrupación
- Detectando líneas verticales
- Capas de agrupamiento promedio
- Capas de agrupamiento máximo
- Capas de agrupamiento global
Agrupando capas
capas convolucionales en una red neuronal convolucional aplican sistemáticamente los filtros aprendidos a las imágenes de entrada para crear mapas de características que resumen la presencia de esas características en la entrada.
Las capas convolucionales resultan muy efectivas, y el apilamiento de capas convolucionales en modelos profundos permite capas cercanas a la entrada para aprender características de bajo nivel (por ejemplo, líneas) y capas más profundas en el modelo para aprender características de orden superior o más abstractas, como formas u objetos específicos.
Una limitación de la salida del mapa de características de la convolucional Yers es que registran la posición precisa de las características en la entrada. Esto significa que pequeños movimientos en la posición de la entidad en la imagen de entrada darán como resultado un mapa de características diferente. Esto puede suceder con el recorte, la rotación, el desplazamiento y otros cambios menores en la imagen de entrada.
Un enfoque común para solucionar este problema del procesamiento de señales se denomina muestreo descendente. Aquí es donde se crea una versión de menor resolución de una señal de entrada que aún contiene los elementos estructurales grandes o importantes, sin los detalles finos que pueden no ser tan útiles para la tarea.
El muestreo descendente se puede lograr con capas convolucionales cambiando El paso de la convolución a través de la imagen. Un enfoque más sólido y común es utilizar una capa de agrupación.
Una capa de agrupación es una nueva capa agregada después de la capa convolucional. Específicamente, después de que se haya aplicado una no linealidad (por ejemplo, ReLU) a la salida de mapas de características por una capa convolucional; por ejemplo, las capas de un modelo pueden tener el siguiente aspecto:
- Imagen de entrada
- Capa convolucional
- No linealidad
- Capa de agrupamiento
La adición de una capa de agrupamiento después de la capa convolucional es un patrón común utilizado para ordenar capas dentro de una red neuronal convolucional que puede repetirse una o más veces en un modelo dado.
La capa de agrupación opera en cada mapa de características por separado para crear un nuevo conjunto del mismo número de mapas de características agrupadas.
implica seleccionar una operación de agrupación, como un filtro que se aplicará a los mapas de características. El tamaño de la operación de agrupación o filtro es más pequeño que el tamaño del mapa de características; específicamente, casi siempre son 2 × 2 píxeles aplicados con un paso de 2 píxeles.
Esto significa que la capa de agrupación siempre reducirá el tamaño de cada mapa de características en un factor de 2, por ejemplo. cada dimensión se reduce a la mitad, reduciendo el número de píxeles o valores en cada mapa de características a un cuarto del tamaño. Por ejemplo, una capa de agrupación aplicada a un mapa de características de 6 × 6 (36 píxeles) dará como resultado un mapa de características agrupadas de salida de 3 × 3 (9 píxeles).
La operación de agrupación se especifica, en lugar de aprenderse. Dos funciones comunes utilizadas en la operación de agrupación son:
- Agrupación promedio : Calcule el valor promedio de cada parche en el mapa de características.
- Agrupación máxima (o agrupación máxima) : Calcule el valor máximo para cada parche del mapa de características.
El resultado de usar una capa de agrupación y crear mapas de entidades muestreados o agrupados es una versión resumida de las características detectadas en la entrada. Son útiles, ya que pequeños cambios en la ubicación de la entidad en la entrada detectada por la capa convolucional darán como resultado un mapa de entidades agrupadas con la entidad en la misma ubicación. Esta capacidad agregada por la agrupación se denomina la invariancia del modelo a la traducción local.
En todos los casos, la agrupación ayuda a que la representación se convierta aproximadamente en invariable para pequeñas traducciones de la entrada. La invarianza a la traducción significa que si traducimos la entrada en una cantidad pequeña, los valores de la mayoría de las salidas agrupadas no cambian.
– Página 342, Aprendizaje profundo 2016.
Ahora que estamos familiarizados con la necesidad y el beneficio de agrupar capas, veamos algunos ejemplos específicos.
Detectando líneas verticales
Antes de ver algunos ejemplos de agrupar capas y sus efectos, desarrollemos un pequeño ejemplo de una imagen de entrada y la capa convolucional a la que luego podemos agregar y evaluar capas de agrupación.
En este ejemplo, definimos una única imagen de entrada o muestra que tiene un canal y es un cuadrado de 8 píxeles por 8 píxeles con todos los valores 0 y una línea vertical de ancho de píxel en el centro.
# define datos de entrada datos = [[0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0]] datos = asarray (datos) data = data.reshape (1, 8, 8, 1)
A continuación, podemos definir un modelo que espera que las muestras de entrada tengan la forma (8, 8, 1) y tenga una sola capa convolucional oculta con un solo filtro con la forma de 3 píxeles por 3 píxeles.
A continuación, se aplica una función de activación lineal rectificada, o ReLU para abreviar, a cada valor en el mapa de características. Esta es una no linealidad simple y efectiva, que en este caso no cambiará los valores en el mapa de características, pero está presente porque luego agregaremos las capas de agrupación subsiguientes y la agrupación se agregará después de la no linealidad aplicada a los mapas de características, por ejemplo. una buena práctica.
# crear modelo modelo = Secuencial () model.add (Conv2D (1, (3,3), activación = 'relu', input_shape = (8, 8, 1))) # resumen modelo model.summary ()
El filtro se inicializa con pesos aleatorios como parte de la inicialización del modelo.
En cambio, codificaremos nuestro propio filtro 3 × 3 que detectará líneas verticales. Es decir, el filtro se activará fuertemente cuando detecte una línea vertical y se activará débilmente cuando no lo haga. Esperamos que al aplicar este filtro en la imagen de entrada, el mapa de características de salida muestre que se detectó la línea vertical.
# define un detector de línea vertical detector = [[[[0]][[1]][[0]]], [[[0]][[1]][[0]]], [[[0]][[1]][[0]]]] pesos = [asarray(detector), asarray([0.0])] # almacenar los pesos en el modelo model.set_weights (pesos)
A continuación, podemos aplicar el filtro a nuestra imagen de entrada llamando a la función predict () en el modelo.
# aplicar filtro a datos de entrada yhat = model.predict (data)
El resultado es una salida de cuatro dimensiones con un lote, un número dado de filas y columnas, y un filtro, o [batch, rows, columns, filters]. Podemos imprimir las activaciones en el mapa de entidades únicas para confirmar que se detectó la línea.
# enumerar filas para r en rango (yhat.shape [1]): # imprimir cada columna en la fila print ([yhat[0,r,c,0] para c en rango (yhat.shape [2])])
Uniendo todo esto, el ejemplo completo se muestra a continuación.
# ejemplo de detección de línea vertical con una capa convolucional de numpy import asarray desde keras.models import Sequential desde keras.layers import conv2D # definir datos de entrada datos = [[0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0]] datos = asarray (datos) data = data.reshape (1, 8, 8, 1) # crear modelo modelo = Secuencial () model.add (Conv2D (1, (3,3), activación = 'relu', input_shape = (8, 8, 1))) # resumen modelo Resumen Modelo() # definir un detector de línea vertical detector = [[[[0]][[1]][[0]]], [[[0]][[1]][[0]]], [[[0]][[1]][[0]]]] pesos = [asarray(detector), asarray([0.0])] # almacenar los pesos en el modelo model.set_weights (pesos) # aplicar filtro a los datos de entrada yhat = model.predict (datos) # enumerar filas para r en rango (yhat.shape [1]): # imprimir cada columna en la fila print ([yhat[0,r,c,0] para c en rango (yhat.shape [2])])
Ejecutar el ejemplo primero resume la estructura del modelo.
Es de destacar que la única capa convolucional oculta tomará el 8 × Imagen de entrada de 8 píxeles y producirá un mapa de características con las dimensiones de 6 × 6.
También podemos ver que la capa tiene 10 parámetros: nueve pesos para el filtro (3 × 3) y un peso para el sesgo .
Finalmente, se imprime el mapa de características únicas.
Al revisar los números en la matriz de 6 × 6 podemos ver que, de hecho, el filtro especificado manualmente detectó la línea vertical en el centro de nuestra imagen de entrada.
_________________________________________________________________ Capa (tipo) Salida Forma Parámetro # ================================================== =============== conv2d_1 (Conv2D) (Ninguno, 6, 6, 1) 10 ================================================== =============== Parámetros totales: 10 Parámetros entrenables: 10 Parámetros no entrenables: 0 _________________________________________________________________ [0.0, 0.0, 3.0, 3.0, 0.0, 0.0] [0.0, 0.0, 3.0, 3.0, 0.0, 0.0] [0.0, 0.0, 3.0, 3.0, 0.0, 0.0] [0.0, 0.0, 3.0, 3.0, 0.0, 0.0] [0.0, 0.0, 3.0, 3.0, 0.0, 0.0] [0.0, 0.0, 3.0, 3.0, 0.0, 0.0]
Ahora podemos ver algunos enfoques comunes de la agrupación y cómo afectan a los mapas de características de salida.
Nivel de agrupación promedio
En los mapas de características bidimensionales, la agrupación se aplica normalmente en parches de 2 × 2 del mapa de características con un paso de (2,2).
El agrupamiento promedio implica calcular el promedio para cada parche del mapa de características. Esto significa que cada cuadrado 2 × 2 del mapa de características se muestrea hacia abajo al valor promedio en el cuadrado.
Por ejemplo, la salida del filtro convolucional del detector de línea en la sección anterior fue un mapa de características de 6 × 6. Podemos observar la aplicación de la operación de agrupación promedio en la primera línea de ese mapa de características manualmente.
La primera línea para agrupar (primeras dos filas y seis columnas) del mapa de características de salida fue la siguiente:
[0.0, 0.0, 3.0, 3.0, 0.0, 0.0] [0.0, 0.0, 3.0, 3.0, 0.0, 0.0]
La primera operación de agrupación se aplica de la siguiente manera:
promedio (0.0, 0.0) = 0.0 0.0, 0.0
Dado el paso de dos, la operación se mueve a lo largo de dos columnas a la izquierda y se calcula el promedio:
promedio (3.0, 3.0) = 3.0 3.0, 3.0
Nuevamente, la operación se mueve a lo largo de dos columnas hacia la izquierda y el promedio se calcula:
promedio (0.0, 0.0) = 0.0 0.0, 0.0
Eso es todo para la primera línea de operaciones de agrupación. El resultado es la primera línea de la operación de agrupamiento promedio:
[0.0, 3.0, 0.0]
Dado el paso (2,2), la operación se movería dos filas hacia la primera columna y el proceso continuaría.
Debido a que la operación de reducción de tamaño a la mitad de cada dimensión, esperaremos que la salida de la agrupación aplicada al mapa de características de 6 × 6 sea un nuevo mapa de características de 3 × 3. Dada la simetría horizontal de la entrada del mapa de características, esperaríamos que cada fila tenga los mismos valores promedio de agrupación. Por lo tanto, esperaríamos que el agrupamiento promedio resultante del mapa de características de línea detectado de la sección anterior se vea como sigue:
[0.0, 3.0, 0.0] [0.0, 3.0, 0.0] [0.0, 3.0, 0.0]
Podemos confirmar esto actualizando el ejemplo de la sección anterior para usar la agrupación promedio.
Esto se puede lograr en Keras usando la capa AveragePooling2D . El tamaño de grupo predeterminado (p. Ej., El tamaño del kernel o el tamaño del filtro) de la capa es (2,2) y el zancadas predeterminado es Ninguno que en este caso significa usar el pool_size como strides que será (2,2).
# create model modelo = Secuencial () model.add (Conv2D (1, (3,3), activación = 'relu', input_shape = (8, 8, 1))) model.add (AveragePooling2D ())
El ejemplo completo con agrupación promedio se muestra a continuación.
# ejemplo de agrupación promedio de numpy import asarray desde keras.models import Sequential desde keras.layers import conv2D Desde keras.layers importan AveragePooling2D # definir datos de entrada datos = [[0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0]] datos = asarray (datos) data = data.reshape (1, 8, 8, 1) # crear modelo modelo = Secuencial () model.add (Conv2D (1, (3,3), activación = 'relu', input_shape = (8, 8, 1))) model.add (AveragePooling2D ()) # resumen modelo Resumen Modelo() # definir un detector de línea vertical detector = [[[[0]][[1]][[0]]], [[[0]][[1]][[0]]], [[[0]][[1]][[0]]]] pesos = [asarray(detector), asarray([0.0])] # almacenar los pesos en el modelo model.set_weights (pesos) # aplicar filtro a los datos de entrada yhat = model.predict (datos) # enumerar filas para r en rango (yhat.shape [1]): # imprimir cada columna en la fila print ([yhat[0,r,c,0] para c en rango (yhat.shape [2])])
Ejecutar el ejemplo primero resume el modelo.
Podemos ver en el resumen del modelo que la entrada a la capa de agrupación será una mapa de entidades único con la forma (6,6) y que la salida de la capa de agrupación promedio será un mapa de entidades único con cada dimensión dividida en dos, con la forma (3,3).
Aplicando los resultados de la agrupación promedio en un nuevo mapa de características que aún detecta la línea, aunque de una manera de muestreo descendente, exactamente como esperábamos al calcular la operación manualmente.
_________________________________________________________________ Capa (tipo) Salida Forma Parámetro # ================================================== =============== conv2d_1 (Conv2D) (Ninguno, 6, 6, 1) 10 _________________________________________________________________ average_pooling2d_1 (Promedio (Ninguno, 3, 3, 1) 0 ================================================== =============== Parámetros totales: 10 Parámetros entrenables: 10 Parámetros no entrenables: 0 _________________________________________________________________ [0.0, 3.0, 0.0] [0.0, 3.0, 0.0] [0.0, 3.0, 0.0]
La agrupación promedio funciona bien, aunque es más común usar la agrupación máxima.
Capa de agrupación máxima
La agrupación máxima, o agrupación máxima, es una operación de agrupación que calcula el valor máximo o máximo en cada parche de cada mapa de características.
Los resultados son mapas de características muestreados o agrupados que resaltan la característica más presente en el parche, no la presencia promedio de la característica en el caso de agrupación promedio. Se ha encontrado que esto funciona mejor en la práctica que el agrupamiento promedio para tareas de visión artificial como la clasificación de imágenes.
En pocas palabras, la razón es que las características tienden a codificar la presencia espacial de algún patrón o concepto en los diferentes mosaicos de la característica. mapa (por lo tanto, el término mapa de características), y es más informativo observar la presencia máxima de características diferentes que en su presencia promedio.
– Página 129, Aprendizaje profundo con Python 2017. [19659005] Podemos concretar la operación de agrupación máxima aplicándola nuevamente al mapa de características de salida de la operación convolucional del detector de línea y calcular manualmente la primera fila de la cartografía de características combinadas.
La primera línea para agrupación (primeras dos filas y seis columnas) del mapa de características de salida fueron las siguientes:
[0.0, 0.0, 3.0, 3.0, 0.0, 0.0] [0.0, 0.0, 3.0, 3.0, 0.0, 0.0]
La primera operación de agrupación máxima se aplica de la siguiente manera:
max (0.0, 0.0) = 0.0 0.0, 0.0
Dado el paso de dos, la operación se mueve a lo largo de dos columnas a la izquierda y se calcula el máximo:
max (3.0, 3.0) = 3.0 3.0, 3.0
Nuevamente, la operación se mueve a lo largo de dos columnas hacia la izquierda y se calcula el máximo:
máx (0.0, 0.0) = 0.0 0.0, 0.0
Eso es todo para la primera línea de operaciones de agrupación.
El resultado es la primera línea de la operación de agrupación máxima:
[0.0, 3.0, 0.0]
De nuevo, dada la simetría horizontal del mapa de características para la agrupación, esperaríamos que el mapa de características agrupadas se vea como sigue:
[0.0, 3.0, 0.0] [0.0, 3.0, 0.0] [0.0, 3.0, 0.0]
Da la casualidad de que la imagen del detector de línea y el mapa de características elegidos producen la misma salida cuando se muestrean con la agrupación promedio y la agrupación máxima.
La operación de agrupación máxima se puede agregar al ejemplo trabajado agregando la Capa MaxPooling2D proporcionada por la API de Keras.
# crear modelo modelo = Secuencial () model.add (Conv2D (1, (3,3), activación = 'relu', input_shape = (8, 8, 1))) model.add (MaxPooling2D ())
El ejemplo completo de detección de línea vertical con agrupación máxima se muestra a continuación.
# ejemplo de agrupación máxima de numpy import asarray desde keras.models import Sequential desde keras.layers import conv2D desde keras.layers import MaxPooling2D # definir datos de entrada datos = [[0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0]] datos = asarray (datos) data = data.reshape (1, 8, 8, 1) # crear modelo modelo = Secuencial () model.add (Conv2D (1, (3,3), activación = 'relu', input_shape = (8, 8, 1))) model.add (MaxPooling2D ()) # resumen modelo Resumen Modelo() # definir un detector de línea vertical detector = [[[[0]][[1]][[0]]], [[[0]][[1]][[0]]], [[[0]][[1]][[0]]]] pesos = [asarray(detector), asarray([0.0])] # almacenar los pesos en el modelo model.set_weights (pesos) # aplicar filtro a los datos de entrada yhat = model.predict (datos) # enumerar filas para r en rango (yhat.shape [1]): # imprimir cada columna en la fila imprimir ([yhat[0,r,c,0] para c en rango (yhat.shape [2])])
Ejecutar el ejemplo primero resume el modelo.
Podemos ver, como podríamos esperar ahora, que la salida del máximo la capa de agrupación será un único mapa de entidades con cada dimensión dividida por la mitad, con la forma (3,3).
Aplicando los resultados máximos de agrupación en un nuevo mapa de características que aún detecta la línea, aunque de forma descendente muestreada. [19659051] _________________________________________________________________
Capa (tipo) Salida Forma Parámetro #
================================================== ===============
conv2d_1 (Conv2D) (Ninguno, 6, 6, 1) 10
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (Ninguno, 3, 3, 1) 0
================================================== ===============
Parámetros totales: 10
Parámetros entrenables: 10
Parámetros no entrenables: 0
_________________________________________________________________
[0.0, 3.0, 0.0]
[0.0, 3.0, 0.0]
[0.0, 3.0, 0.0]
Global Pooling Layers
Hay otro tipo de agrupación que a veces se usa como agrupación global.
En lugar de muestras de muestreo descendente del mapa de características de entrada, la agrupación global muestra la característica completa mapear a un solo valor. Esto sería lo mismo que establecer pool_size en el tamaño del mapa de entidades de entrada.
La agrupación global se puede usar en un modelo para resumir agresivamente la presencia de una entidad en una imagen. A veces también se usa en modelos como alternativa al uso de una capa totalmente conectada para la transición de mapas de características a una predicción de salida para el modelo.
Tanto la agrupación global promedio como la agrupación máxima global son compatibles con Keras a través de GlobalAveragePooling2D y GlobalMaxPooling2D clases respectivamente.
Por ejemplo, podemos agregar la agrupación máxima global al modelo convolucional utilizado para la detección de líneas verticales.
# crear modelo modelo = Secuencial () model.add (Conv2D (1, (3,3), activación = 'relu', input_shape = (8, 8, 1))) model.add (GlobalMaxPooling2D ())
El resultado será un valor único que resumirá la activación más fuerte o la presencia de la línea vertical en la imagen de entrada.
El listado completo de códigos se proporciona a continuación.
# ejemplo de uso de la agrupación máxima global de numpy import asarray desde keras.models import Sequential desde keras.layers import conv2D desde keras.layers importamos GlobalMaxPooling2D # definir datos de entrada datos = [[0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0]] datos = asarray (datos) data = data.reshape (1, 8, 8, 1) # crear modelo modelo = Secuencial () model.add (Conv2D (1, (3,3), activación = 'relu', input_shape = (8, 8, 1))) model.add (GlobalMaxPooling2D ()) # resumen modelo Resumen Modelo() # # definir un detector de línea vertical detector = [[[[0]][[1]][[0]]], [[[0]][[1]][[0]]], [[[0]][[1]][[0]]]] pesos = [asarray(detector), asarray([0.0])] # almacenar los pesos en el modelo model.set_weights (pesos) # aplicar filtro a los datos de entrada yhat = model.predict (datos) # enumerar filas imprimir (yhat)
Al ejecutar el ejemplo, primero se resume el modelo
Podemos ver que, como se esperaba, la salida de la capa de agrupación global es un valor único que resume la presencia de la característica en el mapa de características únicas. [19659005] A continuación, se imprime la salida del modelo que muestra el efecto de la agrupación máxima global en el mapa de características, imprimiendo la activación más grande.
_________________________________________________________________ Capa (tipo) Salida Forma Parámetro # ================================================== =============== conv2d_1 (Conv2D) (Ninguno, 6, 6, 1) 10 _________________________________________________________________ global_max_pooling2d_1 (Glob (Ninguno, 1) 0 ================================================== =============== Parámetros totales: 10 Parámetros entrenables: 10 Parámetros no entrenables: 0 _________________________________________________________________ [[3.]]
Lecturas adicionales
Esta sección proporciona más recursos sobre el tema si desea profundizar.
Publicaciones
Libros
- Capítulo 9: Redes convolucionales, Aprendizaje profundo 2016.
- Capítulo 5: Aprendizaje profundo para la visión por ordenador, Aprendizaje profundo con Python 2017.
API
Resumen
En este tutorial, descubrió cómo funciona la operación de agrupación y cómo implementarla en redes neuronales convencionales. .
Específicamente, aprendió:
- La agrupación es necesaria para muestrear la detección de características en los mapas de características.
- Cómo calcular e implementar la agrupación promedio y máxima en una red neuronal convolucional.
- Cómo usar puesta en común global en una red neuronal convolucional. 19659012] ¿Tiene alguna pregunta?
Haga sus preguntas en los comentarios a continuación y haré todo lo posible para responder.
