Este artículo fue publicado como parte del Blogatón de ciencia de datos.

Fuente: Enlace

¡¡Hey gente!!

En el último artículo, hemos hablado sobre la creación de motores de búsqueda utilizando conceptos de PNL. Si no lo ha leído, consulte este liga.

En este artículo, vamos a hablar sobre una aplicación de clasificación/clasificación de imágenes y es la predicción de neumonía por radiografía de tórax utilizando el modelo apilado previamente entrenado.

La neumonía es causada por bacterias, hongos y virus. Es una infección pulmonar común. Un médico examina la radiografía y puede decir si el paciente sufre de neumonía o no.

La bacteria Streptococcus es la causa principal de la neumonía, causa inflamación en los alvéolos (los sacos de aire en los pulmones) y, debido a la inflamación, los alvéolos se llenan de pus o líquido, lo que dificulta la respiración.

Índice del contenido

• Introducción
• Entendiendo el problema
• Modelo preentrenado de apilamiento
• Implementación

Introducción

Nuestro objetivo es crear un modelo de aprendizaje automático que pueda categorizar los rayos X con neumonía. La implementación de la clasificación o categorización de imágenes puede ser un desafío cuando necesitamos clasificar detalles muy detallados utilizando el modelo apilado previamente entrenado. Como en nuestro escenario, cada radiografía se ve muy similar, pero para capturar detalles muy finos, debemos aplicar algunas técnicas de aprendizaje diferentes que cubriremos en este artículo.

Necesitamos tomar todos y cada uno de los pequeños detalles en nuestro entrenamiento para lograr nuestro objetivo.

• Cuando usamos un modelo de CNN definido, obtuvimos una precisión del 65 %. Simplemente indica que el modelo de CNN en capas personalizado no clasifica las imágenes de rayos X.
• Para lograr una mayor precisión, utilizaremos modelos apilados previamente entrenados.

Comprender el conjunto de datos

Vamos a utilizar el Conjunto de datos de imágenes de rayos X de tórax disponible en Kaggle. puedes descargar o crear un cuaderno Kaggle para trabajar en él.

• El conjunto de datos incluye datos de entrenamiento, prueba y validación.
• Los datos de entrenamiento contienen 5216 radiografías, de las cuales 3875 imágenes son neumónicas y 1341 imágenes son imágenes normales.
• Los datos de validación contienen solo 16 imágenes, incluidas 8 radiografías normales y 8 radiografías con neumonía.
• Los datos de prueba contienen 624 imágenes en las que 390 radiografías neumónicas y 234 radiografías normales.

Implementación del categorizador de rayos X

Usaremos un modelo apilado previamente entrenado que es DensoNet169 y móvilnetv2 para mejores resultados

Esto se hace congelando las capas iniciales e intermedias de modelos previamente entrenados y luego apilándolos para la salida.

Paso 1 Importación de bibliotecas

Estamos importando todas las bibliotecas necesarias a la vez.

de keras.layers.merge importar concatenar de keras.layers importar Entrada de tensorflow.keras.optimizers importar Adam de tensorflow.keras.preprocessing.image importar ImageDataGenerator de tensorflow.keras.layers importar MaxPooling2D, Flatten, Conv2D, Dense, BatchNormalization, GlobalAveragePooling2D ,Dropoutfrom tensorflow.keras.applications.densenet import DenseNet169 from tensorflow.keras.applications.mobilenet_v2 import MobileNetV2

Paso 2 Cargando los datos

El conjunto de datos contiene carpetas jerárquicas para las imágenes de entrenamiento y la validación. hemos guardado la ruta como variables.

• train_n(datos de entrenamiento para rayos X normales)
• train_p(datos de entrenamiento para rayos X de neumonía)
• validation_data_dir (datos de validación)
• test_data_dir( para las pruebas )

main_dir = "../input/chest-xray-pneumonia/chest_xray/" train_data_dir = main_dir + "train/" validation_data_dir = main_dir + "val/" test_data_dir = main_dir + "test/" train_n = train_data_dir+'NORMAL/' train_p = train_data_dir+'NEUMONÍA/'

Paso 3 Crear generador de datos

Dado que el conjunto de datos es grande y para evitar la insuficiencia de memoria, necesitamos entrenar el modelo en lotes, para lograr este propósito usaremos un generador de datos.

Aparte de esto, necesitamos aplicar el aumento de datos para evitar problemas de sobreajuste.

En el aumento de datos, aplicando algunas pequeñas transformaciones logramos resultados más generalizados. esto también lleva a generar más datos de entrenamiento al aplicarles transformaciones.

Los datos Generador de datos de imagen maneja todas las tareas de procesamiento de imágenes.

Note– Aplicamos el aumento de imágenes solo en las imágenes de entrenamiento, no en las imágenes de prueba y validación.

train_datagen = ImageDataGenerator (reescalar = 1. / 255, horizontal_flip = Verdadero)

test_datagen = ImageDataGenerator(reescalar=1. / 255)
val_datagen = ImageDataGenerator(reescalar=1. / 255)

La siguiente transformación de imagen se puede aplicar, es decir,

• zoom_rangeValor flotante: Rangos [inferior, superior]
• shear_rangeValor flotante. Intensidad de corte
• rescale Se utiliza para normalizar la imagen.

Paso 4 Cargando los datos en DataGenerator 

El métodoflow_from_directory carga los datos de forma recursiva yendo directorio por directorio si nuestro directorio principal está de forma jerárquica.

img_width , img_height = [224,224] lote_tamaño = 16

train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='binary', shuffle = True)

validacion_generador = val_datagen.flow_from_directory(
validación_datos_dir,
target_size=(img_height, img_width),
tamaño_lote=tamaño_lote,
class_mode='binario')

test_generator = test_datagen.flow_from_directory(
test_data_dir,
target_size=(img_height, img_width),
tamaño_lote=tamaño_lote,
class_mode='binario')

• class_mode = ‘binary’ ya que es una categorización binaria.
• target_size = (img_height, img_width) del tamaño del objetivo, la imagen debe ser otorgada por el generador de datos de imagen.
• batch_size = 16 Se agruparán 16 imágenes en un lote y el modelo se entrenará tomando el lote de imágenes. Usando lotes solucionamos el problema de la insuficiencia de memoria.

Trazado de las imágenes generadas por Image Data Generator

image_batch, label_batch = siguiente(iter(train_generator))

def show_batch(lote_imagen, lote_etiqueta):
plt.figure (figsize = (10, 10))
para n in rango (15):
hacha = plt.subplot(5, 5, n + 1)
plt.imshow(image_batch[n])
si lote_etiqueta[n]:
plt.title ("NEUMONÍA")
más:
plt.título(“NORMAL”)
plt.eje(“apagado”)

show_batch(lote_imagen, lote_etiqueta)

Paso 5 Construcción de modelos

Usaremos pre-entrenados DensoNet169 y móvilnetv2 y apilará las últimas capas pre-entrenadas usando la clase de combinación.

Congelar las capas superiores e intermedias significa que mantenemos los pesos previamente entrenados y no lo estamos entrenando desde cero.

forma_entrada = (224,224,3) capa_entrada = Entrada(forma = (224, 224, 3))

#primer modelo
mobilenet_base = MobileNetV2(pesos = 'imagennet',input_shape = input_shape,include_top = False)

densenet_base = DenseNet169 (pesos = 'imagenet', input_shape = input_shape, include_top = False)

para capa in mobilenet_base.layers: layer.trainable = Falso para capa in densenet_base.layers: layer.trainable = False model_mobilenet = mobilenet_base(input_layer) model_mobilenet = GlobalAveragePooling2D()(model_mobilenet) output_mobilenet = Flatten()(model_mobilenet)

model_densenet = densanet_base(capa_entrada)
model_densenet = GlobalAveragePooling2D()(model_densenet)
salida_densenet = Aplanar()(modelo_densenet)

combinado = tf.keras.layers.Concatenate()([output_mobilenet, output_densenet])

x = Normalización por lotes () (fusionado)
x = denso (256, activación = 'relu') (x)
x = Abandono(0.5)(x)
x = Normalización por lotes()(x)
x = denso (128, activación = 'relu') (x)
x = Abandono(0.5)(x)
x = Densa(1, activación = 'sigmoide')(x)
modelo_apilado = tf.keras.models.Model(entradas = capa_entrada, salidas = x)

• Congelar todas las capas superiores e intermedias para mantener los pesos previamente entrenados y solo entrenar el modelo para la salida después del apilamiento.

La mayoría de los modelos CNN pre-entrenados están entrenados en el imagenet conjunto de datos

• tf.keras.layers.Concatenate() Concatena las salidas para apilar.
• stacked_model es el modelo final listo para las predicciones.

Compilación de modelos

Hasta ahora hemos diseñado nuestro modelo, es hora de asignar algunos parámetros de aprendizaje y compilar el modelo.

• LR = 0.0001
• optimizador = adam

Estamos probando el optimizador Adam y LR = 0.0001, la pequeña tasa de aprendizaje es el mejor comienzo para el modelo pre-entrenado.

optm = Adam(lr=0.0001) stacked_model.compile(loss='binary_crossentropy', Optimizer=optm, metrics=['accuracy'])

Paso 6 Definición de devoluciones de llamada

Las devoluciones de llamada son una herramienta para un entrenamiento eficiente, pero su uso no es obligatorio y nos da control sobre el entrenamiento.

de keras.callbacks import EarlyStopping,ReduceLROnPlateau EarlyStopping = EarlyStopping(monitor='val_accuracy', min_delta=.01,patient=6, verbose=1, mode='auto',baseline=Ninguno, restore_best_weights=True)

EarlyStopping: Detiene el entrenamiento si el modelo no obtiene mejores resultados después de algunas épocas.

rlr = ReduceLROnPlateau( monitor="val_accuracy", factor=0.01, paciencia=6, detallado=0, modo="max", min_delta=0.01)

ReduceLROnPlateau Reduce la tasa de aprendizaje (LR) si el modelo no mejora.

model_save = ModelCheckpoint('./stacked_model.h5', save_best_only = True, save_weights_only = False, monitor = 'val_loss', mode = 'min', detallado = 1)

ModelCheckpoint : guarda el modelo en varias épocas.

Paso 7 Entrenamiento

Ahora que estamos listos con el modelo y los datos, es hora de comenzar el entrenamiento.

nb_tren_muestras = 5216 # número de muestras de entrenamiento
nb_validación_muestras = 16 # número de muestras de validación
nb_test_muestras = 624 # número de muestras de entrenamiento
épocas = 20 tamaño_lote = 16

Formación

stacked_history = stacked_model.fit(train_generator, pasos_por_epoch = nb_train_samples // tamaño_lote, épocas = 20, validation_data = test_generator, callbacks=[EarlyStopping, model_save,rlr])

• maximum val_accuracy La precisión máxima que tenemos es 93% y la pérdida es .18 la pérdida mínima. El modelo y el entrenamiento se pueden mejorar aún más mediante el ajuste fino y el apilamiento de algunos modelos más densos.

Paso 8 Prueba del modelo

Al probar el rendimiento del modelo mediante la creación de una función de predicción, se ingresa una imagen y el nombre del modelo y se indica si se trata de una radiografía normal o una radiografía neumónica.

def procesar_imagen(imagen): imagen = imagen/255 imagen = cv2.resize(imagen, (224,224)) devolver imagen

La función preprocess_image() toma la matriz de imágenes y la normaliza dividiéndola por 255 y redimensionándola a (224,224).

def predecir(ruta_de_imagen, modelo): im = cv2.imread(ruta_de_imagen) imagen_de_prueba = np.asarray(im) imagen_de_prueba_procesada = imagen_de_proceso(imagen_de_prueba) imagen_de_prueba_procesada = np.expand_dims(imagen_de_prueba_procesada, eje = 0) ps = model.predict(imagen_de_prueba_procesada) volver pd

La funciónpredict() ingresa la ruta de la imagen image_path y modelo y predicción de retornos.

de sklearn.metrics import Classification_report,confusion_matrix

de la imagen de importación PIL

prueba de definición (modelo, test_df):
base_pred=[]
para la imagen in prueba_df.img_ruta:
base_pred.append(predecir(imagen, modelo)[0][0])

final_base_pred = np.where(np.array(base_pred)>0.5,1,0)
etiqueta_actual = test_df['etiqueta']
# imprimir(final_base_pred)

imprimir (informe_clasificación (etiqueta_real, base_pred_final))
matriz=confusion_matrix(actual_label, final_base_pred)
sb.heatmap(matriz,cuadrado=Verdadero, annot=Verdadero, fmt='d', cbar=Falso,
xticklabels=['0', '1'],
yticklabels=['0', '1'])
plt.xlabel('Etiqueta prevista')
plt.ylabel('Etiqueta verdadera')

La funcióntesting() se hace para devolver la matriz de confusión y el informe de entrenamiento para una mejor comprensión del rendimiento de nuestro modelo.

pruebas (modelo_apilado, prueba_df)

Matriz de confusión

Conclusión

En este artículo, discutimos la implementación del modelo apilado preentrenado para nuestra segregación de imágenes de rayos X. Discutimos el funcionamiento del generador de datos de imagen, y usando API funcional construimos nuestro modelo y usando devoluciones de llamada lo hemos entrenado.

Lista de verificación

• El modelo apilado que entrenamos tiene la pérdida más baja en 20 épocas y la precisión de validación más alta
• Puedes probar (CLAHE y normalización) para una mayor precisión.
• Apilar varios modelos con una arquitectura más densa puede prometer un mejor resultado.

Espero que les haya gustado mi artículo sobre el modelo apilado preentrenado. Siéntase libre de golpearme LinkedIn si tienes algo que preguntar.

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor. 

Relacionado:

• Coinsmart. El mejor intercambio de Bitcoin y criptografía de Europa.
• Platoblockchain. Inteligencia del Metaverso Web3. Conocimiento amplificado. ACCESO LIBRE.
• CriptoHawk. Radar de altcoins. Prueba gratis.
• Fuente: https://www.analyticsvidhya.com/blog/2022/03/x-ray-classification-using-pretrained-stacked-model/