Detección de COVID-19 a partir de imágenes de rayos X de tórax con CNN

Una aplicación web basada en Django creada con el propósito de detectar la presencia de COVID-19 a partir de imágenes de rayos X de tórax con múltiples modelos de aprendizaje automático entrenados en arquitecturas preconstruidas. Se utilizaron tres modelos diferentes de aprendizaje automático para construir este proyecto, a saber, Xception, ResNet50 y VGG16. El modelo de aprendizaje profundo se entrenó en un conjunto de datos disponible públicamente, el conjunto de datos SARS-COV-2-Ct-Scan . El propósito de este proyecto es aplicar Arquitecturas de Redes Neuronales Convolucionales (CNN) en la resolución de problemas de la pandemia en una etapa preliminar.

Herramientas y tecnologías utilizadas

Algunas bibliotecas y tecnologías importantes utilizadas se enumeran a continuación.

• Lenguaje de programación: Python
• Marco Web: Django
• Marco de aprendizaje automático: Tensorflow
• Desarrollo frontend: HTML, CSS (BootStrap)
• Bibliotecas esenciales: keras, sklearn, venv, seaborn, matplotlib

Puede encontrar una lista detallada de todas las bibliotecas aquí .

Implementación paso a paso

Parte de aprendizaje profundo

1) Convertir conjunto de datos en marco de datos

• Descargue el conjunto de datos desde aquí
• Convierta los datos en un marco de datos de pandas con las columnas correspondientes
  • Archivo [Archivo de imagen]
  • ID de enfermedad [Número de serie]
  • Tipo de enfermedad [COVID, no COVID]

train_dir = 'path/to/dataset'
train_data = []
  
for defects_id, sp in enumerate(disease_types):
    for file in os.listdir(os.path.join(train_dir, sp)):
        train_data.append(['{}/{}'.format(sp, file), defects_id, sp])
          
train = pd.DataFrame(train_data, columns=['File', 'DiseaseID', 'Disease Type'])

2) Leer y preprocesar el marco de datos

• Leer las imágenes
• Convierta las imágenes al tamaño estándar de (64 x 64)
• Cree arrays numpy para entrada/salida X_Train & Y_Train
• Normalice los valores RGB dividiendo por 255.

IMAGE_SIZE = 64
  
def read_image(filepath):
    return cv2.imread(os.path.join(data_dir, filepath))
  
def resize_image(image, image_size):
    return cv2.resize(image.copy(), image_size, 
                      interpolation=cv2.INTER_AREA)
  
X_train = np.zeros((train.shape[0], IMAGE_SIZE, IMAGE_SIZE, 3))
  
for i, file in tqdm(enumerate(train['File'].values)):
    image = read_image(file)
    if image is not None:
        X_train[i] = resize_image(image, (IMAGE_SIZE, IMAGE_SIZE))
          
X_Train = X_train / 255.
  
Y_train = train['DiseaseID'].values
Y_train = to_categorical(Y_train, num_classes=2)

3) Dividir el conjunto de datos en tren/validación

• Dividir en tren, conjuntos de datos de validación
• Seleccione el porcentaje de división y el estado aleatorio en consecuencia

X_train, X_val, Y_train, Y_val = train_test_split(
  X_Train, Y_train, test_size=0.2, random_state = 42)

4) Definir la arquitectura del modelo

• Vamos a importar tres arquitecturas diferentes que se enumeran a continuación:
  • VGG16
  • ResNet50
  • Xcepción
• Estructura de la Arquitectura Modelo
  • Conv2D de forma de entrada (3,3)
  • Arquitectura ResNet50/Xception/VGG16
  • Agregue un GlobalAveragePooling2D()
  • Agregar una capa de abandono
  • Capa DenseNet final con activación relu
  • Para salida múltiple, agregue una capa Softmax
• Use un optimizador ‘adam’, los hiperparámetros se pueden ajustar en consecuencia
• El siguiente código propone un código de muestra para construir un modelo

def build_model():
  
    # Use Any One of the Following Lines
    resnet50 = ResNet50(weights='imagenet', include_top=False)
    xception = Xception(weights='imagenet', include_top=False)
    vgg16 = VGG16(weights='imagenet', include_top=False)
  
    input = Input(shape=(SIZE, SIZE, N_ch))
    x = Conv2D(3, (3, 3), padding='same')(input)
  
    # Use Any One of the Following Lines
    x = resnet50(x)
    x = xception(x)
    x = vgg16(x)
  
    x = GlobalAveragePooling2D()(x)
    x = BatchNormalization()(x)
    x = Dropout(0.5)(x)
    x = Dense(256, activation='relu')(x)
    x = BatchNormalization()(x)
    x = Dropout(0.5)(x)
  
    # multi output
    output = Dense(2, activation='softmax', name='root')(x)
  
    # model
    model = Model(input, output)
  
    optimizer = Adam(lr=0.003, beta_1=0.9, beta_2=0.999,
                     epsilon=0.1, decay=0.0)
      
    model.compile(loss='categorical_crossentropy',
                  optimizer=optimizer, metrics=['accuracy'])
      
    model.summary()
  
    return model

5) Entrena al modelo

• Llamar a la función build_model()
• Utilice un recocido, una devolución de llamada que supervisa una cantidad y, si no se observa ninguna mejora durante un número de épocas de «paciencia», la tasa de aprendizaje se reduce.
• Use un ImageDataGenerator para llevar a cabo un aumento de datos de imágenes en tiempo real
• Entrena el modelo en x_train, y_train
• Guarde los pesos del modelo en formato .hdf5 y el gráfico del modelo en formato .json

# Use Any one of the Lines Below
hdf5_save = 'ResNet50_Model.hdf5'
hdf5_save = 'Xception_Model.hdf5'
hdf5_save = 'VGG16_Model.hdf5'
  
model = build_model()
annealer = ReduceLROnPlateau(
    monitor='val_accuracy', factor=0.70, patience=5,
    verbose=1, min_lr=1e-4)
  
checkpoint = ModelCheckpoint(h5f5_save, verbose=1, save_best_only=True)
  
datagen = ImageDataGenerator(rotation_range=360,
                             width_shift_range=0.2,
                             height_shift_range=0.2,
                             zoom_range=0.2,
                             horizontal_flip=True,
                             vertical_flip=True)
  
datagen.fit(X_train)
  
# Use Any one of the lines Below
model_graph = 'ResNet50.json'
model_graph = 'Xception.json'
model_graph = 'VGG16.json'
  
model_json = model.to_json()
with open(model_graph, "w") as json_file:
    json_file.write(model_json)

Creación de la aplicación web

• Cree un proyecto Django con una aplicación inicializada en su interior que usaría los pesos del modelo guardados para predecir las imágenes de rayos X de tórax cargadas
• Cree una página estática básica con un formulario para enviar el archivo de imagen al backend

<form method="post" id="imageForm" enctype="multipart/form-data">
   {% csrf_token %}
   <label for="ImgFile">Upload Image</label>
   <input type="file" name="ImgFile" class="form-control"/>
   <input type="submit" id="submitButton" class="btn" name="submit" value="Solve"/>
</form>

• Dentro de la carpeta views.py, maneje la imagen cargada. Cargue los archivos del modelo y envíe la respuesta al front-end.
• La respuesta contendría los siguientes detalles
  • Predicción del modelo
  • Puntuación de confianza
  • Duración de la predicción (en s)
• Agregue estilo a la interfaz usando CSS (Bootstrap) en consecuencia

Nota: Cargar varios modelos y usar model.predict() lleva mucho tiempo y sería mucho más si no hubiera servicios de GPU en la instancia de la nube. Para escalar esta aplicación a una mayor carga del servidor, considere usar TensorFlow Serving

Manifestación

Una versión de demostración del proyecto creado y probado en localhost se muestra en el siguiente video

Demostración de COV-CNN

Aplicaciones en la vida real y el trabajo futuro

El proyecto construido en las líneas anteriores no se puede aplicar directamente, sin embargo, muchas de esas aplicaciones se pueden construir en una tangente similar para cumplir el propósito del diagnóstico médico preliminar basado en los aportes de los pacientes, ahorrando una gran cantidad de costos de la etapa de detección a la industria médica. . La canalización de aprendizaje automático presentada en el proyecto se puede mejorar si se hace dinámica por naturaleza. Al agregar más datos de entrenamiento dinámicamente al modelo y entrenarlo sobre ellos para mejorar su precisión. El modelo ML se puede convertir en una API REST, lo que hace que la aplicación sea más robusta y escalable. Se podría utilizar una base de datos MySQL para almacenar datos de pacientes con detalles de diagnóstico y otros parámetros.

Recursos

• Repositorio de GitHub: https://github.com/dwaipayan05/CovCNN-WebApp
• Google Drive Link: Cuaderno/Archivos de peso/Conjunto de datos