Este artículo fue publicado como parte del Blogatón de ciencia de datos.
Hey Guys,
Espero que todos estéis bien.
En este artículo, aprenderemos cómo puede desarrollar e implementar un clasificador de imágenes usando un matraz. Al igual que mis otros artículos, este artículo le brindará experiencia práctica con el código y, al final de este artículo, podrá crear una API de matraz simple y efectiva que clasificará la imagen. Este artículo contendrá inicialmente la parte teórica y luego la parte de codificación. Le daré un enlace al código más adelante en este artículo que le ahorrará el ajetreo. Así que centrémonos en el aprendizaje. Nuevamente, este artículo estará completamente basado en PYTHON.
Este artículo está abierto para todas las categorías de espectadores (Principiante, Intermedio, Avanzado). A continuación se muestra la tabla de contenido de este artículo, así que siéntase libre de omitir partes con las que ya se sienta cómodo.
Esta parte se centrará en el clasificador de imágenes usando matraz. Puedes encontrar la segunda parte. esta página si solo está interesado en crear una API de matraz.
Tabla de Contenido
- ¿Qué es la clasificación de imágenes?
1. 1. Red neuronal convolucional
1. 2. Transferir el aprendizaje - Codificación para el clasificador de imágenes
- Conclusión
Clasificación de imagen
La clasificación de imágenes es el proceso de categorizar y etiquetar grupos de píxeles o vectores dentro de una imagen según reglas específicas. En términos simples, estamos tratando de agrupar de alguna manera imágenes relacionadas o imágenes similares.
Las técnicas de clasificación de imágenes se dividen principalmente en dos tipos: clasificación de imágenes no supervisada y supervisada. Aquí utilizaremos las técnicas de clasificación de imágenes supervisadas. No profundizaré más en ello.
El Estado del Arte para la clasificación de imágenes se basa en el Aprendizaje Profundo conocido como Redes Neuronales Convolucionales (CNN).
Red neuronal convolucional
Antes de pasar a CNN, echemos un vistazo a Neural Network.
Red neuronal: Estos son una serie de algoritmos que reconocen los patrones/relaciones subyacentes en un conjunto de datos a través de un proceso que imita el funcionamiento del cerebro humano. Aprendizaje profundo: un subconjunto de algoritmos de aprendizaje automático que es muy bueno para reconocer patrones, pero que normalmente requiere una gran cantidad de datos.
CNN También conocido como Convnet, es un tipo especial de red neuronal que funciona de la misma manera que una red neuronal normal, excepto que tiene una capa de convolución al principio.
¿Por qué usamos CNN?
- Las redes neuronales feedforward simples no ven ningún orden en sus entradas. Si mezclara todas sus imágenes de la misma manera, la red neuronal tendría el mismo rendimiento que tenía cuando se entrenaba en imágenes no mezcladas.
- aprovechar la coherencia espacial local de las imágenes. Esto significa que pueden reducir drásticamente la cantidad de operaciones necesarias para procesar una imagen mediante el uso de convolución en parches de píxeles adyacentes porque los píxeles adyacentes juntos son significativos.
- Usan algo llamado capa de agrupación para reducir la resolución de su imagen.
La siguiente imagen muestra un ejemplo clásico de CNN.
Términos VIP en CNN
Circunvolución: Contiene un conjunto de filtros/núcleos (conjunto de pesos) que toma la entrada como un subconjunto de la imagen de entrada. Los subconjuntos de imágenes se multiplican con los filtros que generalmente son de menor tamaño que la imagen. La siguiente imagen lo ayudará a obtener información sobre la capa Convolucional.
Agrupación: Esta capa ayuda a reducir la resolución de nuestras imágenes. Ejecutamos un filtro sobre la matriz y aplicamos una función sobre ella para generar la salida. MAXPOOL es una función que da salida como valor máximo como se muestra a continuación en la imagen.
La imagen está tomada de https://cs231n.github.io/convolutional-networks/
Rehacer
La función de activación lineal rectificada o ReLU para abreviar es una función lineal por partes que generará la entrada directamente si es positiva; de lo contrario, generará cero. Se ha convertido en la función de activación predeterminada para muchos tipos de redes neuronales porque un modelo que la usa es más fácil de entrenar y, a menudo, logra un mejor rendimiento.
Punteras
Esta capa ayuda a evitar el sobreajuste de nuestro modelo al descartar aleatoriamente ciertos nodos en la red neuronal y usar el descanso para la predicción. Es una técnica de regularización que obliga a CNN a no depender solo de ciertos nodos sino que tiene un componente o dice de todos los nodos.
Capa completamente conectada
Las neuronas en una capa completamente conectada tienen conexiones completas con todas las activaciones en la capa anterior. Por lo tanto, sus activaciones se pueden calcular con una multiplicación de matriz seguida de una compensación de polarización.
Puedes leer más detalles haga clic aquí
Transferir aprendizaje
Transfer Learning es la reutilización de un modelo previamente aprendido en un nuevo problema. Estas son las técnicas más utilizadas en Computer Vision porque ahorran mucho trabajo cuando usa estas técnicas para resolver un nuevo problema similar. Por ejemplo, creamos un modelo para clasificar gato vs mono, ¿podemos usarlo para clasificar tigre vs gorila? Con Transfer learning, seguro que podemos.
Vamos a utilizar transferencia de aprendizaje también mientras creamos nuestro modelo. Ejemplos de modelos de aprendizaje de transferencia utilizados para la clasificación de imágenes son Resnet50, MobileNet, VGG16, VGG19, DenseNet.
Leer más sobre Transferencia de aprendizaje haga clic aquí
Basta de teorías ¡MUÉSTRAME EL CÓDIGO!
Codificación para clasificador de imágenes
Para los clasificadores de imágenes, hay muchos módulos como TensorFlow, PyTorch,fastai, etc. Para este blog, usaremos TensorFlow.
Importar bibliotecas:
# Bibliotecas auxiliares import os import numpy as np import matplotlib.pyplot as plt
# Tensorflow importa tensorflow como tf
desde tensorflow.keras.applications.imagenet_utils import preprocess_input, decode_predictions
desde tensorflow.keras.models import load_model, model_from_json, Modelo
de tensorflow.keras.preprocessing importar imagen de tensorflow importar keras from keras.preprocessing.image import ImageDataGenerator
Creando tu conjunto de datos
Tienes que declarar y cambiar variables de acuerdo a tu uso.
# Declaración de variables train_data_dir = 'v_data/train' validation_data_dir = 'v_data/test' nb_train_samples =400 nb_validation_samples = 100 epochs = 10 batch_size = 16img_width, img_height=224,224input_shape=(img_width, img_height,3)
épocas: 1 época es cuando el conjunto de datos completo se pasa hacia adelante y hacia atrás a través de la red neuronal solo una vez.
tamaño del lote: Dado que pasar el conjunto de datos completo hacia adelante y hacia atrás hará que aumente el costo de cómputo, usamos un tamaño de lote que se define como la cantidad de muestras que se propagarán a través de la red.
train_datagen = ImageDataGenerator( rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_width, img_height), tamaño_de_lote=tamaño_de_lote, modo_de_clase='binario') generador_de_validación = generación_de_datos.flujo_desde_directorio(dir_datos_de_validación, tamaño_objetivo=(ancho_de_imagen, alto_de_imagen), tamaño_de_lote=tamaño_de_lote, modo_de_clase='binario')
Creando modelo
model=Sequential()model.add(Conv2D(32, (2,2), input_shape=input_shape))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2,2)))model.add(Conv2D(32, (2,2)))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2,2)))model.add(Conv2D(64, (2,2)))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2,2)))model.add(Flatten())model.add(Dense(64))model.add(Activation('relu'))model.add(Dropout(0.5))model.add(Dense(1))model.add(Activation('sigmoid'))
Hemos creado la estructura para nuestro modelo aquí.
|
El código anterior creará una función de compilación que contendrá la función de pérdida, el optimizador como Adam y la evaluación del modelo.
Transferir el modelo de aprendizaje
desde tensorflow.keras.applications.mobilenet_v2 import MobileNetV2 model = MobileNetV2(weights='imagenet')
Este código creará un modelo con la estructura de MobileNetV2 cargado con pesos de imagenet.
Ajuste fino del modelo de aprendizaje por transferencia
Para ajustar las redes neuronales preentrenadas para nuestro problema, necesitamos entrenarlas en nuestro conjunto de datos. También podemos agregar algunas capas adicionales al final del modelo de clasificación de imágenes.
de keras.applications import Resnet50 base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(IMG_SIZE, IMG_SIZE, 3))
output_categories = 2 # número de categorías en la capa final. add_model = Sequential() add_model.add(Flatten(input_shape=base_model.output_shape[1:])) add_model.add(Dropout(0.3)) add_model.add(Dense(128, activación='relu')) add_model.add( Dropout(0.3)) add_model.add(Dense(output_categories, activate='softmax')) model = Model(inputs=base_model.input, outputs=add_model(base_model.output))
Aquí hemos usado Resnet50 como un modelo preentrenado y luego agregamos algunas capas al final de nuestro modelo para que podamos ajustarlo para nuestro caso.
Modelo de entrenamiento
model.fit_generator(train_generator, steps_per_epoch=nb_train_samples // tamaño_lote, epochs=épocas, validation_data=generador_validación, validation_steps=nb_validation_samples // tamaño_lote)
Predecir usando el modelo
def model_predict(img, modelo): img = img.resize((224, 224))
# Preprocesando la imagen x = image.img_to_array(img) # x = np.true_divide(x, 255) x = np.expand_dims(x, axis=0)
# Tenga cuidado con la forma en que su modelo entrenado maneja la entrada # de lo contrario, ¡no hará una predicción correcta! x = entrada_preproceso(x, modo='tf')
preds = model.predict(x) devolver preds
Guardar modelo
model_json = model.to_json() with open("ImageClassifier.json", "w") as json_file: json_file.write(model_json) # serializar pesos a HDF5 model.save_weights("ImageClassifier.h5")
Las ubicaciones cambiarán según su sistema.
Cargando modelo
model_json = open(path_to_model_json, 'r')loaded_model_json = model_json.read() model_json.close() model = model_from_json(loaded_model_json) model.load_weights(path_to_model_wieght)
En caso de que esté confundido y quiera ver o copiar el código. Referencia para clasificador de imágenes esta página.
Conclusión
Este es el final del clasificador de imágenes usando matraz. Espero que tenga una idea de cómo puede crear un clasificador de imágenes y cómo puede aplicar el aprendizaje de transferencia y usarlo para obtener mejores resultados para sus problemas de visión por computadora. En el artículo de seguimiento, crearemos una API para almacenar nuestro clasificador de imágenes e implementarlo. Ya puse el código completo para este tutorial en el repositorio de GitHub a continuación.
ENCONTRAR CÓDIGO haga clic aquí
ABOUT ME
Soy un estudiante de último año de IIIT cursando mi licenciatura en Ciencias de la Computación e Ingeniería. Me encanta explorar y probar más y más sobre Deep and Machine Learning. Si quieres colaborar puedes utilizar los siguientes enlaces:
Linkedin: Haz click en mi
Github: Haz click en mi
Kaggle: Haz click en mi
Escribeme: GME@dhr-rgv.com
Espero que les haya gustado mi artículo sobre el clasificador de imágenes usando Flask. ¡Gracias por leer!
Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.
