Modelos preentrenados para la incrustación de imágenes
Modelos preentrenados para la incrustación de imágenes
Los 10 mejores modelos preentrenados para la incrustación de imágenes que todo científico de datos debe conocer
Guía esencial para transferir el aprendizaje
Los rápidos desarrollos en visión artificial: los casos de uso de clasificación de imágenes se han acelerado aún más con la llegada del aprendizaje por transferencia. Se necesitan muchos recursos computacionales y tiempo para entrenar un modelo de red neuronal de visión por computadora en un gran conjunto de datos de imágenes.
Afortunadamente, este tiempo y recursos se pueden acortar mediante el uso de modelos previamente entrenados. La técnica de aprovechar la representación de características de un modelo previamente entrenado se denomina aprendizaje de transferencia. Los pre-entrenados generalmente se entrenan utilizando recursos computacionales de alta gama y en conjuntos de datos masivos.
Los modelos pre-entrenados para la incrustación de imágenes se pueden utilizar de varias maneras:
- Usar los pesos preentrenados y hacer predicciones directamente sobre los datos de prueba
- Usar los pesos preentrenados para inicializar y entrenar el modelo usando el conjunto de datos personalizado
- Usar solo la arquitectura de la red preentrenada y entrenarla desde cero en el conjunto de datos personalizado
Este artículo recorre los 10 mejores modelos preentrenados de última generación para incrustar imágenes. Todos estos modelos preentrenados se pueden cargar como modelos keras mediante la API keras.application .
Arquitectura de CNN discutida en este artículo: 1) VGG 2) Xception 3) ResNet 4) InceptionV3 5) InceptionResNet 6) MobileNet 7) DenseNet 8) NasNet 9) EfficientNet 10) ConvNEXT
Licencia: Todas las imágenes utilizadas en este artículo son de paperwithcode.com , que tiene licencia CC BY-SA 4.0.
1) VGG:
Las redes VGG-16/19 se presentaron en la conferencia ILSVRC 2014, ya que es uno de los modelos preentrenados más populares. Fue desarrollado por el Visual Graphics Group de la Universidad de Oxford.
Hay dos variaciones del modelo VGG: red de 16 y 19 capas, siendo VGG-19 (red de 19 capas) una mejora del modelo VGG-16 (red de 16 capas).
Arquitectura:
La red VGG es de naturaleza simple y secuencial y utiliza muchos filtros. En cada etapa, se utilizan filtros pequeños (3*3) para reducir el número de parámetros.
La red VGG-16 tiene lo siguiente:
- Capas convolucionales = 13
- Capas de agrupación = 5
- Capas densas completamente conectadas = 3
Entrada: Imagen de dimensiones (224, 224, 3)
Salida: incrustación de imagen de 1000 dimensiones
Otros detalles para VGG-16/19:
- Enlace en papel: https://arxiv.org/pdf/1409.1556.pdf
- GitHub: VGG
- Publicado el: abril de 2015
- Rendimiento en el conjunto de datos de ImageNet: 71 % (Precisión de los 1 principales), 90 % (Precisión de los 5 principales)
- Número de parámetros: ~140M
- Número de capas: 16/19
- Tamaño en disco: ~530 MB
Implementación:
- Llamada
tf.keras.applications.vgg16.preprocess_inputen sus datos de entrada para convertir imágenes de entrada a BGR con centro cero para cada canal de color. - Cree una instancia del modelo VGG16 utilizando el código mencionado a continuación:
tf.keras.applications.VGG16(
include_top=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
)
El código mencionado anteriormente es para la implementación de VGG-16, Keras ofrece una API similar para la implementación de VGG-19, para obtener más detalles, consulte esta documentación .
2) Xcepción:
Xception is a deep CNN architecture that involves depthwise separable convolutions. A depthwise separable convolution can be understood as an Inception model with a maximally large number of towers.
Arquitectura:
Entrada: Imagen de dimensiones (299, 299, 3)
Salida: incrustación de imagen de 1000 dimensiones
Otros detalles de Xception:
- Enlace en papel: https://arxiv.org/pdf/1409.1556.pdf
- GitHub: Xcepción
- Publicado el: abril de 2017
- Rendimiento en el conjunto de datos de ImageNet: 79 % (Precisión de los 1 principales), 94,5 % (Precisión de los 5 principales)
- Número de parámetros: ~30M
- Profundidad: 81
- Tamaño en disco: 88 MB
Implementación:
- Cree una instancia del modelo Xception utilizando el código mencionado a continuación:
tf.keras.applications.Xception(
include_top=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
)
El código mencionado anteriormente es para la implementación de Xception, para obtener más detalles, consulte esta documentación .
3) ResNet:
The previous CNN architectures were not designed to scale to many convolutional layers. It resulted in a vanishing gradient problem and limited performance upon adding new layers to the existing architecture.
La arquitectura ResNets ofrece omitir conexiones para resolver el problema del gradiente de fuga.
Arquitectura:
This ResNet model uses a 34-layer network architecture inspired by the VGG-19 model to which the shortcut connections are added. These shortcut connections then convert the architecture into a residual network.
Hay varias versiones de la arquitectura ResNet:
- ResNet50
- ResNet50V2
- ResNet101
- ResNet101V2
- ResNet152
- ResNet152V2
Entrada: Imagen de dimensiones (224, 224, 3)
Salida: incrustación de imagen de 1000 dimensiones
Otros detalles para los modelos ResNet:
- Enlace en papel: https://arxiv.org/pdf/1512.03385.pdf
- GitHub: ResNet
- Publicado el: diciembre de 2015
- Rendimiento en el conjunto de datos de ImageNet: 75–78 % (Precisión de los 1 principales), 92–93 % (Precisión de los 5 principales)
- Número de parámetros: 25–60M
- Profundidad: 107–307
- Tamaño en disco: ~100–230 MB
Implementación:
- Cree una instancia del modelo ResNet50 utilizando el código mencionado a continuación:
tf.keras.applications.ResNet50(
include_top=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs
)
El código mencionado anteriormente es para la implementación de ResNet50, keras ofrece una API similar a otras implementaciones de arquitectura ResNet, para obtener más detalles, consulte esta documentación .
4) Inicio:
Multiple deep layers of convolutions resulted in the overfitting of the data. To avoid overfitting, the inception model uses parallel layers or multiple filters of different sizes on the same level, to make the model wider rather than making it deeper. The Inception V1 model is made of 4 parallel layers with: (1*1), (3*3), (5*5) convolutions, and (3*3) max pooling.
Inception (V1/V2/V3) is deep learning model-based CNN network developed by a team at Google. InceptionV3 is an advanced and optimized version of the InceptionV1 and V2 models.
Arquitectura:
El modelo InceptionV3 está compuesto por 42 capas. La arquitectura de InceptionV3 se construye progresivamente paso a paso como:
- Convoluciones factorizadas
- Circunvoluciones más pequeñas
- Circunvoluciones asimétricas
- Circunvoluciones auxiliares
- Reducción del tamaño de la cuadrícula
Todos estos conceptos se consolidan en la arquitectura final que se menciona a continuación:
Entrada: Imagen de dimensiones (299, 299, 3)
Salida: incrustación de imagen de 1000 dimensiones
Otros detalles para los modelos InceptionV3:
- Enlace en papel: https://arxiv.org/pdf/1512.00567.pdf
- GitHub: Origen V3
- Publicado el: diciembre de 2015
- Rendimiento en el conjunto de datos de ImageNet: 78 % (Principal 1 de precisión), 94 % (Top 5 de precisión)
- Número de parámetros: 24M
- Profundidad: 189
- Tamaño en disco: 92 MB
Implementación:
- Cree una instancia del modelo InceptionV3 utilizando el código mencionado a continuación:
tf.keras.applications.InceptionV3(
include_top=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
)
El código mencionado anteriormente es para la implementación de InceptionV3; para obtener más detalles, consulte esta documentación .
5) InceptionResNet:
InceptionResNet-v2 is a CNN model developed by researchers at Google. The target of this model was to reduce the complexity of InceptionV3 and explore the possibility of using residual networks on the Inception model.
Arquitectura:
Entrada: Imagen de dimensiones (299, 299, 3)
Salida: incrustación de imagen de 1000 dimensiones
Otros detalles para los modelos Inception-ResNet-V2:
- Enlace en papel: https://arxiv.org/pdf/1602.07261.pdf
- GitHub: Inicio-ResNet-V 2
- Publicado el: agosto de 2016
- Rendimiento en el conjunto de datos de ImageNet: 80 % (Precisión de los 1 principales), 95 % (Precisión de los 5 principales)
- Número de parámetros: 56M
- Profundidad: 189
- Tamaño en disco: 215 MB
Implementación:
- Cree una instancia del modelo Inception-ResNet-V2 utilizando el código mencionado a continuación:
tf.keras.applications.InceptionResNetV2(
include_top=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
**kwargs
)
El código mencionado anteriormente es para la implementación de Inception-ResNet-V2; para obtener más detalles, consulte esta documentación .
6) Red móvil:
MobileNet is a streamlined architecture that uses depthwise separable convolutions to construct deep convolutional neural networks and provides an efficient model for mobile and embedded vision applications.
Arquitectura:
Entrada: Imagen de dimensiones (224, 224, 3)
Salida: incrustación de imagen de 1000 dimensiones
Otros detalles para los modelos MobileNet:
- Enlace en papel: https://arxiv.org/pdf/1602.07261.pdf
- GitHub: MobileNet-V3 , MobileNet-V2
- Publicado el: abril de 2017
- Rendimiento en el conjunto de datos de ImageNet: 71 % (Precisión de los 1 principales), 90 % (Precisión de los 5 principales)
- Número de parámetros: 3.5–4.3M
- Profundidad: 55–105
- Tamaño en disco: 14–16 MB
Implementación:
- Cree una instancia del modelo MobileNet utilizando el código mencionado a continuación:
tf.keras.applications.MobileNet(
input_shape=None,
alpha=1.0,
depth_multiplier=1,
dropout=0.001,
include_top=True,
weights="imagenet",
input_tensor=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
**kwargs
)
The above-mentioned code is for MobileNet implementation, keras offers a similar API to other MobileNet architecture (MobileNet-V2, MobileNet-V3) implementation, for more details refer to this documentation.
7) Red densa:
DenseNet is a CNN model developed to improve accuracy caused by the vanishing gradient in high-level neural networks due to the long distance between input and output layers and the information vanishes before reaching the destination.
Arquitectura:
A DenseNet architecture has 3 dense blocks. The layers between two adjacent blocks are referred to as transition layers and change feature-map sizes via convolution and pooling.
Entrada: Imagen de dimensiones (224, 224, 3)
Salida: incrustación de imagen de 1000 dimensiones
Otros detalles para los modelos DenseNet:
- Enlace en papel: https://arxiv.org/pdf/1608.06993.pdf
- GitHub: DenseNet-169 , DenseNet-201 , DenseNet-264
- Publicado el: enero de 2018
- Rendimiento en el conjunto de datos de ImageNet: 75–77 % (Principal 1 de precisión), 92–94 % (Top 5 de precisión)
- Número de parámetros: 8–20M
- Profundidad: 240–400
- Tamaño en disco: 33–80 MB
Implementación:
- Cree una instancia del modelo DenseNet121 utilizando el código mencionado a continuación:
tf.keras.applications.DenseNet121(
include_top=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
)
The above-mentioned code is for DenseNet implementation, keras offers a similar API to other DenseNet architecture (DenseNet-169, DenseNet-201) implementation, for more details refer to this documentation.
8) NasNet:
Google researchers designed a NasNet model that framed the problem to find the best CNN architecture as a Reinforcement Learning approach. The idea is to search for the best combination of parameters of the given search space of a number of layers, filter sizes, strides, output channels, etc.
Entrada: Imagen de dimensiones (331, 331, 3)
Otros detalles para los modelos NasNet:
- Enlace en papel: https://arxiv.org/pdf/1608.06993.pdf
- Publicado el: abril de 2018
- Rendimiento en el conjunto de datos de ImageNet: 75–83 % (Principal 1 de precisión), 92–96 % (Top 5 de precisión)
- Número de parámetros: 5–90M
- Profundidad: 389–533
- Tamaño en disco: 23–343 MB
Implementación:
- Cree una instancia del modelo NesNetLarge utilizando el código mencionado a continuación:
tf.keras.applications.NASNetLarge(
input_shape=None,
include_top=True,
weights="imagenet",
input_tensor=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
)
El código mencionado anteriormente es para la implementación de NesNet, keras ofrece una API similar a la implementación de otra arquitectura NasNet (NasNetLarge, NasNetMobile), para obtener más detalles, consulte esta documentación .
9) Red Eficiente:
EfficientNet is a CNN architecture from the researchers of Google, that can achieve better performance by a scaling method called compound scaling. This scaling method uniformly scales all dimensions of depth/width/resolution by a fixed amount (compound coefficient) uniformly.
Arquitectura:
Otros detalles de los modelos EfficientNet:
- Enlace en papel: https://arxiv.org/pdf/1905.11946v5.pdf
- GitHub: EfficientNet
- Publicado el: septiembre de 2020
- Rendimiento en el conjunto de datos ImageNet: 77–84 % (Principal 1 de precisión), 93–97 % (Top 5 de precisión)
- Número de parámetros: 5–67M
- Profundidad: 132–438
- Tamaño en disco: 29–256 MB
Implementación:
- Cree una instancia del modelo EfficientNet-B0 utilizando el código mencionado a continuación:
tf.keras.applications.EfficientNetB0(
include_top=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
**kwargs
)
El código mencionado anteriormente es para la implementación de EfficientNet-B0, keras ofrece una API similar para la implementación de otra arquitectura EfficientNet (EfficientNet-B0 a B7, EfficientNet-V2-B0 a B3), para obtener más detalles, lea esta documentación, y esta sobre Keras.
10) ConvNext:
El modelo ConvNeXt CNN se propuso como un modelo convolucional puro (ConvNet), inspirado en el diseño de Vision Transformers, que pretende superarlos.
Arquitectura:
Otros detalles para los modelos ConvNeXt:
- Enlace en papel: https://arxiv.org/pdf/1905.11946v5.pdf
- GitHub: ConvNeXt
- Publicado el: marzo de 2022
- Rendimiento en el conjunto de datos de ImageNet: 81–87 % (Principal 1 en precisión)
- Número de parámetros: 29–350M
- Tamaño en disco: 110–1310 MB
Implementación:
- Cree una instancia del modelo ConvNeXt-Tiny usando el código mencionado a continuación:
tf.keras.applications.ConvNeXtTiny(
model_name="convnext_tiny",
include_top=True,
include_preprocessing=True,
weights="imagenet",
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation="softmax",
)
El código mencionado anteriormente es para la implementación de ConvNeXt-Tiny, keras ofrece una API similar de la otra implementación de la arquitectura
EfficientNet (ConvNeXt-Small, ConvNeXt-Base, ConvNeXt-Large, ConvNeXt-XLarge), para obtener más detalles, consulte esta documentación
Resumen:
He discutido 10 arquitecturas populares de CNN que pueden generar incrustaciones utilizando el aprendizaje de transferencia. Estos modelos de CNN preentrenados han superado el conjunto de datos de ImageNet y han demostrado ser los mejores.
La biblioteca de Keras ofrece API para cargar la arquitectura y los pesos de los modelos preentrenados discutidos. Las incrustaciones de imágenes generadas a partir de estos modelos se pueden utilizar para varios casos de uso.
Sin embargo, este es un dominio en continuo crecimiento y siempre hay una nueva arquitectura de CNN que esperar.
Referencias:
[1] Artículos con código: https://paperswithcode.com/sota/image-classification-on-imagenet
[2] Documentación de Keras: https://keras.io/api/applications/
Gracias por leer
