Please ensure Javascript is enabled for purposes of website accessibility

Detector de COVID-19 usando imágenes de Rayos X

Fuente: Detector de COVID-19 usando imágenes de Rayos X
Christian Tutivén Gálvez

Christian Tutivén Gálvez Mar 25, 2020 · 17 min read

COVID-D Detection
COVID-D Detection

Entre profesores, investigadores y estudiantes creamos un grupo de trabajo con la finalidad de ayudar al sistema de salud pública del Ecuador, ahora que estamos viviendo esta pandemia del coronavirus (COVID-19) alrededor del mundo. Uno de los problemas que hemos evidenciado en este tiempo es la falta de mecanismos alternativos y eficaces -aparte del test médico vigente- para la detección de COVID-19. Por esto, es que queremos compartir un trabajo que puede ser útil, como apoyo para los médicos al momento de detectar este virus, evitando congestionar los hospitales, clínicas, centros de salud, etc.

En concreto, compartimos cómo fue el desarrollo de nuestro clasificador de COVID-19 usando radiografías, para que cualquier persona interesada en seguir investigando o que desee colaborar, lo pueda hacer. Además, hemos desarrollado una aplicación web que contiene el modelo entrenado, el cual deseamos compartir con el Ministerio de Salud Pública (MSP). Así que te invitamos a compartir y difundir esta información. Juntos podemos lograr que se salven más vidas, pues la tarea es de todos.

Este trabajo lo realizamos en conjunto con Ángel Encalada y Andrés Torres. Y agradecimientos a Xavier Guerrero y a todas las personas que nos han ayudado con imágenes para validar nuestro modelo.

Descargo de responsabilidad: Este no es un estudio científicamente riguroso, ni será publicado en una revista. Es una versión beta que puede mejorarse de muchas maneras. El dataset de imágenes debe agrandarse y etiquetarse por profesionales de la salud. Este artículo es para lectores que estén interesados ​​en (1) Visión por computadora / Aprendizaje profundo y quieran aprender a través de métodos prácticos y (2) que sea una herramienta de apoyo para los doctores y para todo el sistema sanitario, más no un reemplazo a su trabajo.

Problemática

Debido al incremento de casos de COVID-19 positivos, casos no confirmados e incertidumbre, encontramos los siguientes problemas:

1- Los centros de salud públicos no pueden realizar pruebas para detección del COVID-19 a tantas personas (número que cada día incrementa).

2- Los call center están congestionados.

3- Los laboratorios privados cobran entre los 200 a 300 dólares por una prueba de detección.

Objetivos del proyecto final

En este proyecto, entrenaremos un clasificador de imágenes para identificar si un persona tiene COVID-19 o no, usando radiografías, las cuales tienen un costo entre $15 a $25 . Puedes imaginarte usar algo como esto en una aplicación de teléfono o en tu pc. En la práctica, se entrena a este clasificador y luego lo se lo exporta para usarlo en una aplicación. En este artículo les mostraremos como utilizamos FASTAI para completar el proyecto.

A continuación puedes ver algunos ejemplos de las imágenes a clasificar.

Uso de radiografías para detectar el COVID
Distintas radiografías que se usaron para entrenar el modelo.

Para alguien que no es experto en imágenes médicas va ser muy difícil detectar a simple vista si es un caso positivo de COVID-19 o no.

Observación: queremos destacar que el objetivo es que sea una herramienta de APOYO para los doctores (no para tener una decisión final).

Herramientas usadas

Haremos una introducción a dos herramientas que usamos para crear nuestro modelo:

1- Fastai

2- Google Colab

Fastai, una biblioteca de python que busca simplificar la Inteligencia Artificial (IA)

Fastai, una biblioteca de python que busca simplificar la Inteligencia Artificial
fast.ai startup

Una startup llamada Fast.ai tiene como objetivo ayudar a los desarrolladores a llevar a cabo tareas relacionadas con IA usando su biblioteca de aprendizaje profundo para Python (fastai).

Fast.ai fue cofundado por dos empleados de la Universidad de San Francisco. Rachel Thomas es profesora en la universidad, mientras que Jeremy Howard es científico investigador.

Python se ha convertido casi en sinónimo de desarrollo de inteligencia artificial debido a que es rápido, robusto, portátil y escalable. Algunos de los marcos de inteligencia artificial más populares del mundo, como Pytorch, TensorFlow y Keras, están diseñados para Python.

Hay una gran curva de aprendizaje cuando se trata de hacer uso de los marcos existentes que pueden ser a la vez desalentadores y frustrantes. Fast.ai quiere reducir el tiempo que le toma a un desarrollador comenzar con la IA.

Por todo esto, decidimos usar esta librería para entrenar nuestro modelo y que sea sencillo de entender y así doctores e investigadores puedan seguir colaborando en este trabajo.

¿Qué es Google Colab?

Google Colab
Google Colab

Esta herramienta de Google ofrece el uso de un portátil tipo jupyter. El portátil tiene la misma extensión (.ipynb) y funciona de la misma manera que en Jupyter. Se puede usar como un cuaderno de jupyter un entorno local instalado en la máquina personal de uno (esto no se tratará en este artículo), no obstante, para poder aprovechar toda su potencia, se podría utilizar mejor una GPU disponible (en Google Colab) e instalar los paquetes necesarios (es muy fácil, no te asustes).

Para los que se mueren de hambre por más detalles, Google tiene un cuaderno “Te damos la bienvenida a Colaboratory” que tiene como objetivo dar una introducción detallada a la herramienta.

https://colab.research.google.com/notebooks/welcome.ipynb

El Proyecto

El proyecto se divide en varios pasos:

* Cargar y pre-procesar el conjunto de datos de la imagen.
* Entrena el clasificador de imágenes en tu conjunto de datos.
* Usa el clasificador entrenado para predecir el contenido de la imagen.

Esta guía te ayudará a desarrollar cada paso y como implementarlo en fastai usando el entorno de Google Colab.

Empezando con Google Colab

Google Colab ofrece una GPU Tesla K80. Se puede seguir trabajando con la instancia de GPU continuamente hasta 12 horas! Una vez que hayan consumido las 12 horas, simplemente cierra el cuaderno y vuelve a abrirlo. Ahora, ¡a trabajar!

Para configurar Google Colab puedes leer mi articulo en este link (no leer la parte de pytorch ya que usaremos fastai).

Dataset

El conjunto de datos de imágenes de rayos X COVID-19 que usaremos para este tutorial fue recogido por el Dr. Joseph Cohen, becario postdoctoral en la Universidad de Montreal.

Hace unas semana, el Dr. Cohen comenzó a recopilar imágenes de rayos X de los casos de COVID-19 y a publicarlas en el siguiente repositorio de GitHub.

Dentro del repositorio encontrarás ejemplos de casos de COVID-19, y otros también como MERS, SARS y ARDS.

Lo primero que hicimos fue descargar el repositorio GitHub. Puedes descargarlo manualmente o usar el comando (en caso que sepas usarlo)

!wget https://github.com/ieee8023/covid-chestxray-dataset

Al revisar los archivos, encontramos que existe una carpeta llamada images que contiene todas las imágenes y un archivo metadata.csv que contiene información tabular de cada unas de las imágenes, como por ejemplo las etiquetas que nos indican que enfermedad se le detecto (COVID-19, SARS, ARDS, Pneumocystis, etc.), tipo de imagen (X-ray o CT), view que nos da el tipo de toma de la radiografía (PA, L, Axial, AP, etc.), entre otras. Recomendamos que revises este archivo y quizás encuentres información importante que no fue tomada en cuenta en este trabajo.

La estructura de archivos que vamos a necesitar para entrenar el modelo es:

path/
/train/covid
/train/nocovid/
/validation/covid/
/validation/nocovid/
/valid/nocovid
/test/

Como se puede observar para las imágenes de entrenamiento y validación tenemos dos carpetas (covid y nocovid). Como la finalidad del trabajo es detectar COVID-19 necesitamos guardar en las subcarpetas covid todas las imágenes etiquetadas como tal y en las subcarpetas nocovid cualquier otro tipo de virus (SARS, ARDS, Pneumocystis, etc). Además, no se hizo distinción del tipo de toma ( columna view en el archivo metadata.csv) de la radiografía, es decir, queremos que sea cual sea la toma (PA, AP, L, etc) aprenda a detectar si es COVID-19 o no.

Puedes ver que la carpeta test no tiene subcarpetas. Esto se debe a que estas son las imágenes que el modelo nunca ha visto y vamos a probar para saber que etiqueta les pone. Por esto ahí van imágenes COVID-19 positivo y negativo.

Para crear el conjunto de datos de imágenes de rayos X COVID-19 para este tutorial, se realizaron las distintas tareas:

1- Se revisó el archivo metadata.csv

2- Se realizo un script (se puede descargar pero debes realizar modificaciones de ruta según tu ordenador) que lea el archivo metadata.csv y usando las columnas finding, view y modality para poder crear nuestros dataset de entrenamiento, validación y testeo y, además, las divida en las subcarpetas covid y nocovid. En las carpetas train usamos el 70% del total de imágenes, en validation el 15% y en test el 15% restante.

2.1- Guardamos en una carpeta llamada CT las imágenes etiquetadas como modality ct (tomografía computarizadas), ya que solo usaremos radiografías (Ray-X). Las de tipo ct no las usaremos pero deseamos guardarlas para alguna otra investigación. Puedes haber escuchado o leído que las tomografías son más eficientes a la hora de ayudar a detectar COVID-19 pero son más difíciles de conseguir y nuestra misión y evitar que el sistema sanitario colapse.

Nos dimos cuenta que no existían imágenes de pacientes sanos ni con neumonía así que tomamos una muy buena idea del artículo de Adrian Rosebrok (link del articulo) y descargamos el conjunto de datos de imágenes de rayos X del tórax de Kaggle (Kaggle’s Chest X-Ray Images (Pneumonia) dataset). Escogimos 40 radiografías al azar de saludable y 40 de neumonía y las agregamos a las subcarpeta nocovid de la carpeta train. Hicimos lo mismo con 40 imágenes distintas de cada clase pero ahora para la carpeta validación y 20 de cada clase para la carpeta test.

Después de reunir mi conjunto de datos, me quedaron 315 imágenes en total . El dataset de entrenamiento conformado por 77 imágenes de rayos X positivos para COVID-19 y 76 imágenes de rayos X de pacientes sin COVID-19.

He incluido mi conjunto de datos el siguiente link Descargas datasets, por lo que no tienes que volver a crearlo.

Además, he incluido mis scripts Python utilizados para generar el conjunto de datos en este link, pero estos scripts no serán revisados ​​en este tutorial ya que están fuera del alcance de la publicación.

Implementación de nuestro script de clasificación COVID-19 o no, usando Fastai

Pues empecemos. Lo primero es abrir un portatil Jupyter en Colab y escribir

!curl -s https://course.fast.ai/setup/colab | bash

para actualizar la librearía fastai.

Como estamos usando google Colab y no deseamos que cada vez que se reinicie la máquina que nos da google tengamos que volver a subir nuestro dataset, lo ideal es subir las imágenes a google drive y establecer una conexión, ejecutando el siguiente comando

from google.colab import drivedrive.mount(‘/content/gdrive’, force_remount=True)

Aparecerá un link al cual debes ingresar y dar autorización de acceso a tu espacio en Google Drive. Obtendrás un código que debes copiarlo y pegarlo en

link para acceso a tu espacio en google drive

Importar librerías

Ahora debes importar las librerías que vas a usar

from fastai import *
from fastai.vision import *
from fastai.metrics import error_rate

El símbolo * significa que estamos importando todo de las librerías fastai y fastai.vision.

Definir objetos

Ahora definimos la ruta donde está nuestro dataset.

path = Path('gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/')

En tu caso puede ser otra ruta pero la puedes encontrar, dándole click a la carpeta que aparece del lado izquierdo de google colab, y encontrarás la carpeta gdrive y explorando un poco busca donde están tus imágenes. Copia la ruta y úsala.

Para asegurarnos que seleccionamos correctamente la ruta, veamos que tenemos adentro

path.ls()

Se mostraran las carpetas que tenemos adentro

[PosixPath('gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/pneumonia'),
PosixPath('gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/normal'),
PosixPath('gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/train'),
PosixPath('gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/validation'),
PosixPath('gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/test'),
PosixPath('gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/models')]

Algunas de estas carpetas son nuestras por lo que a ti no te aparecerán. Lo que si debes ver son las carpetas train, validation y test que son donde están nuestras imágenes con las que trabajaremos.

También podemos visualizar una de las imágenes escribiendo lo siguiente (tomar en cuenta la ruta y el nombre de la imagen).

img = open_image(path/'train/covid/1-s2.0-S1684118220300682-main.pdf-002-a2.png')
print(img.data.shape)
img.show()

El resultado sera la siguiente imagen7

Imagen de prueba

Recordemos que el split fue aleatorio así que quizás esta imagen se encuentre en otra de las carpetas y no en train.

Ahora seleccionamos el tamaño de nuestro batch (uno de los hyper parámetros de nuestro modelo). No entraremos en detalles técnicos pero batch son la cantidad de imágenes por grupo que pasaremos a nuestra red.

bs = 16

Seleccionamos una semilla (seed) para tener los mismos resultados.

np.random.seed(7)

Creamos un objeto de tipo get_transforms que nos permitirá aumentar nuestro dataset con imágenes que se crean a partir de las imágenes de nuestro dataset de entrenamiento pero con modificaciones. Por ejemplo, tendremos imágenes con máximo de rotación de 25 grados y giro horizontal. Esto nos ayuda a reducir el sobre entrenamiento (overfitting), ya que aunque sean modificaciones de las imágenes iniciales son distintas a las mismas. Si eres un experto en imágenes medicas quizás sugieras realizar otras transformaciones por lo que te doy el link con información de las transformaciones posibles.

tfms = get_transforms(do_flip=True,flip_vert=False, max_rotate=25)

Ahora cargaremos nuestras imágenes en un objeto de tipo ImageDataBunch. Este objeto de fastai nos permite cargar directamente las imágenes desde una carpeta (en este caso), definir el número de imágenes por batch, identificar cuales son para entrenamiento, validación y testeo, realizar las transformaciones definidas previamente, hacer que todas las imágenes tengan el mismo tamaño, etc. Para mayor información visita el link.

data = ImageDataBunch.from_folder(path, train="train", valid='validation', test='test', ds_tfms=tfms, size=224, bs=bs, num_workers=4).normalize(imagenet_stats)

Ahora podemos visualizar ejemplos de imágenes usando la función show_batch al cual le debemos pasar la cantidad de filas y columnas que deseamos mostrar y el tamaño (juega con estos valores para que veas como cambian). Recordar que cada vez que ejecutes esta función mostrará imágenes aleatorias.

data.show_batch(3, figsize=(6,6))

En nuestro caso decidimos que muestre 3 filas y 3 columnas

show_batch

Ahora veamos como se crearon nuestros datasets.

data.c, len(data.train_ds), len(data.valid_ds), len(data.test_ds), len(data.classes)

de resultado obtendremos

(2, 153, 79, 83, 2)

que significa que tenemos dos clases y tenemos 153 imágenes para entrenar, 79 para validar y 83 de test.

Construyendo y entrenando el clasificador

Ahora que los datos están listos, es hora de construir y entrenar al clasificador. Como de costumbre, usaremos uno de los modelos pre-entrenados para obtener las características de la imagen.

En los últimos años, se han creado varios modelos para reutilizarlos en problemas de visión de computadora. El uso de estos modelos pre-entrenados se conoce como aprendizaje por transferencia. Fastai hace que sea fácil cargar modelos pre-entrenados y construir sobre ellos, que es lo que haremos en este proyecto.

Algunos de los modelos pre-entrenados más populares incluyen VGGNet, DenseNet, ResNet y AlexNet, todos los cuales son modelos pre-entrenados del Challenge de ImageNet. Estos modelos pre-entrenados permiten que otros obtengan rápidamente resultados de vanguardia en visión por computadora sin necesidad de grandes cantidades de poder de cómputo, tiempo y paciencia para encontrar la técnica de entrenamiento adecuada para optimizar los pesos.

Decidimos usar la arquitectura Resnet34, sin embargo, otros modelos podrían haberse utilizado fácilmente con una configuración muy similar (información).

learn = cnn_learner(data, models.resnet34, metrics=error_rate)

En general, lo que se está haciendo es crear un objeto llamado learn de tipo cnn_learner (una red convolucional), se le está pasando el objeto data, se le dice que use el modelo pre-entrenado resnet34 y que use la métrica error_rate con el dataset de validación. Existen otras métricas que podrías usar así que revisa la información.

Debes ver que se descarga el modelo.

Ahora sí lo interesante. Vamos a entrenar nuestro modelo

learn.fit_one_cycle(4)

Se usó el método llamado fit_one_cycle (paper). El valor que se le está pasando es la cantidad de épocas que deseamos que entrenar. En general épocas son las cantidades de veces que toda nuestra data pasa por la red en sentido foward y backward (actualización de pesos). Muchas épocas puede provocar sobre entrenamiento (overfit), ya que ve las mismas imágenes muchas veces y solo aprende a reconocer esas imágenes pero no aprender a generalizar con imágenes nuevas.

Resultados del entrenamiento (modelo 1)

Podemos ver que obtuvimos un modelo con un error rate de 10% en tan solo 1 minuto 21 segundos de entrenamiento. En conclusión con un entrenamiento de tan poco tiempo logramos acertar correctamente aproximadamente 90% del tiempo. Además, podemos observar que tan solo hemos ejecutado aproximadamente 10 lineas de código y ya tenemos un buen modelo. Esto es lo que hace genial a Pytorch y a fastai.

Ahora deseamos guardar nuestro modelo para poder usarlo más adelante. Para esto creamos un directorio donde guardar el modelo (puedes definir la ruta que desees).

dest=Path(base_dir + “models/covidnocovid/”)
try:
dest.mkdir(parents=True, exist_ok=False)
except FileExistsError:
print (‘File Already Exists’)

Y guardamos el modelo en un archivo .pth

learn.save(dest/’covidnocovid_stage-1’)

Pero, ¿qué significan estos resultados?

Para ver los resultados de mejor manera fastai nos lo facilita. Para esto, creamos un objeto de tipo ClassificationInterpretation de nuestro objeto learn.

interp = ClassificationInterpretation.from_learner(learn)

Una de las cosas más utiles de es llamado plot_top_losses que nos indica que tan buena fue nuestra predicción.

interp.plot_top_losses(9, figsize=(15,11))
Top_losses (modelo 1)

Si tomamos como ejemplo la imagen de la primera columna y tercera fila, nos imprime cuatro cosas predicción/actual/loss/probabilidad de clase actual (mayor información).

Estas herramientas nos sirven para verificar en que hemos fallado comúnmente.

También podemos visualizar la matriz de confusión

Matriz de confusión (modelo 1)

La diagonal nos indica en cuantos ejemplos hemos acertado.

Mejorando nuestro modelo

Pues hemos obtenido un buen modelo pero, ¿cómo podemos mejorarlo? quizás haciendo un mejor tuneo de los parámetros.

Nuestro modelo anterior fue entrenado en 4 épocas y de manera muy rápida. ¿Por qué paso esto? Porque usamos un pequeño truco llamado transferencia de aprendizaje.

Estos modelos de aprendizaje profundo tienen muchas capas.

¿Qué hicimos?
Agregamos algunas capas adicionales al final de la arquitectura y solo entrenamos esas. Dejamos la mayoría de las primeras capas como estaban. Esto se llama capas congeladas, es decir, los pesos de esas capas no se modificaron. Entonces por eso fue rápido.

Si queremos construir un modelo bastante similar al modelo pre entrenado original, en este caso, similar a los datos de Imagenet (dataset con el que fue entrenado) que funcionan bastante bien debemos entrenar todas las capas.

¿Qué queremos hacer?
Volver atrás y entrenar a todo el modelo. Por eso es que siempre usamos este proceso de 2 estados:

1- cuando llamamos a fit o fit_one_cycle() en create_cnn, afinará estas capas adicionales al final y se ejecutará muy rápido.

2- Nunca se sobreajustará, pero para hacerlo bien, debemos llamar a

learn.unfreeze()

para descongelar los pesos de todas las capas y poder actualizarlos con el entrenamiento.

Ahora usaremos una función muy útil que nos recomendara que taza de aprendizaje (learning rate) usar

learn.lr_find()
learn.recorder.plot()
plt.title("Loss Vs Learning Rate")
plt.show()
LR Finder

Esto trazará el resultado de nuestro LR finder y lo que esto muestra es el parámetro clave llamado tasa de aprendizaje. La tasa de aprendizaje indica qué tan rápido estamos actualizando los parámetros en nuestro modelo. El eje x aquí me muestra lo que sucede a medida que aumenta la tasa de aprendizaje. El eje y muestra cuál es la pérdida. Como puedes ver, una vez que la tasa de aprendizaje pasa de 10e-4, nuestra pérdida empeora.

La taza de aprendizaje predeterminada es de 0.003 = 10e–3 y fue la usada cuando entrenamos nuestro modelo. Debido a que estamos tratando de ajustar las cosas ahora, no podemos usar una tasa de aprendizaje tan alta. Entonces, según el LR finder, tratamos de elegir algo bien antes de que empeorara. Entonces decidimos usar 1e-6 (tiene pendiente negativa, es decir reduce el loss). Pero no tiene sentido entrenar todas las capas a ese ritmo porque sabemos que las capas posteriores funcionaron bien antes, cuando entrenamos mucho más rápido. Entonces, lo que podemos hacer es pasar un rango de tasas de aprendizaje a learn.fit_one_cycle. Y lo hacemos así:

learn.unfreeze()
learn.fit_one_cycle(10, max_lr=slice(1e-6, 1e-4))

Utilizamos la palabra clave en Python llamada slice y así podemos tomar un valor inicial y un valor final y, básicamente, lo que dice es entrenar las primeras capas a una velocidad de aprendizaje de 1e-6, y las últimas capas a una velocidad de 1e- 4, y distribuya todas las otras capas entre esos dos valores por igual. Y al hacer eso obtenemos

Resultados del entrenamiento (modelo 2)

Como podemos observar en 10 épocas hemos obtenido un error rate del 3%, es decir, que acertaremos en la clase correcta el 97% de las veces. Osea, tuvimos una mejora del 7%.

interp = ClassificationInterpretation.from_learner(learn)interp.plot_top_losses(9, figsize=(15,11))

Ahora guardaremos nuestro nuevo modelo

learn.save(dest/’covidnocovid_stage-2’)

Y visualizaremos los mismos resultados como lo hicimos con nuestro primer modelo

interp.plot_confusion_matrix(figsize=(12,12), dpi=60)
interp.plot_top_losses(9, figsize=(15,11))
Top losses (modelo 2)
interp.plot_confusion_matrix(figsize=(12,12), dpi=60)
Matriz de confusión (modelo 2)

Se puede evidenciar la mejora en la clasificación de covid y nocovid.

Modelo en producción

Ahora deseamos verificar que nuestro modelo funcione con imágenes que nunca ha visto. Para esto, cargamos una imagen de nuestro dataset de testeo y la mostramos (previamente revisamos que etiqueta debería tener y era nocovid)

img = learn.data.test_ds[54][0]
img
Imagén de testeo

Ahora vamos a predecir qué clase es esta imagen

learn.predict(img)

y el resultado nos da

(Category noCovid, tensor(1), tensor([1.9421e-05, 9.9998e-01]))

Aquí, nuestro modelo predijo que esta imagen es de clase noCovid que corresponde a la etiqueta 1. Y las probabilidades que encontró para cada una de las clases fue de 1.9421e-05 y 9.9998e-01 respectivamente.

Te adjuntamos el link de descarga del script.

Comentarios

Finalmente, hemos desarrollado una app que contiene el modelo y al cargar una radiografía dará un resultado de COVID-19 positivo o negativo. Esta aplicación la deseamos compartir con el sistema sanitario del Ecuador (ministerio de salud) para que conjuntamente podamos validar los resultados, dar un apoyo a los doctores, conseguir más imágenes y poder realizar investigaciones que nos ayuden a mejorar este sistema.

Les compartimos unas fotos de la aplicación.

Ingreso de datos e imagen
Resultado

Conclusiones

Gracias a fastai y a Google Colab para entrenar un detector de COVID-19 automático en un conjunto de imágenes de rayos X, en poco tiempo y con pocas líneas de código.

Las imágenes usadas fueron descargadas del dataset Joseph Cohen’s GitHub repo of open-source X-ray images. Nuestra misión es poder colaborar con el ministerio de salud y centros médicos que puedan ayudarnos a aumentar los datos de entrenamiento y así mejorar el modelo.

Usamos una red pre entrenada para reducir los tiempos de entrenamiento y en un primer modelo obtuvimos un accuracy del 90%. Y al ajustar la taza de aprendizaje pudimos mejorar nuestro modelo al 97%.

La red pre entrenada que se usó fue la Resnet34 pero también obtuvimos buenos resultados con la Resnet50 pero el tiempo de entrenamiento es mayor y el tamaño del archivo del modelo. Existen muchos tipos de redes pre entrenadas que puedes probar y los invitamos a hacerlo.

Las radiografías usadas son de personas de otros países y no de Ecuador. No podemos opinar si esto afecta o no al modelo porque esto requiere una mayor investigación y no es nuestro campo. Esta parte se la dejamos a los expertos en salud y aclaramos que nuestra intención es el de poder colabaorar y combinar su experiencia con este tipo de herramientas. Queremos mostrar que se puede realizar algo similar y trabajar en conjunto con el MSP para seguir investigando con radiofrafías de personas de nuestro país.

Para aumentar nuestro dataset usamos algunas transformaciones pero un experto en imágenes médicas podrían recomendar realizar transformaciones adicionales y hasta preferir no realizar las que nosotros usamos. Así también pueden existir otras métricas distintas a la usada (error rate) para medir la eficiencia del modelo y tener distintos resultados.

No somos expertos en imágenes médicas por lo que solo dejamos que el algoritmo aprenda a encontrar información espacial en las radiografías que permita distinguir una clase de otra.

Tenga en cuenta que el detector COVID-19 cubierto en este tutorial no es un estudio cientícamente riguroso, ni será publicado en una revista. Nuestro objetivo es inspirar a los profesionales de aprendizaje profundo, investigadores y expertos en imágenes médicas a ver cómo el aprendizaje profundo y la visión por computadora pueden ser un apoyo.

Espero que hayan disfrutado esta publicación.