Get best of the week

Detector COVID-19 automatizado a partir de imagens de fluorografia



Neste guia, você aprenderá como detectar automaticamente o COVID-19 em um conjunto de dados especialmente selecionado usando Keras, TensorFlow e aprendizado profundo.

Como a maioria das pessoas no mundo atualmente, estou sinceramente preocupado com o COVID-19. Percebo que comecei a analisar constantemente minha saúde pessoal e suspeito que já tenha sido infectado.

Quanto mais me preocupo com isso, mais uma dolorosa combinação de sintomas reais com hipocondria se manifesta:

  • Acordei de manhã, me sinto um pouco sobrecarregado.
  • Quando saí da cama, já havia um vazamento no nariz (embora agora se saiba que o nariz escorrendo não é um sintoma do COVID-19).
  • Enquanto ele chegava ao banheiro para pegar um guardanapo, ele também tossiu.

No começo, não dei muita importância a isso - sou alérgico ao pólen e, devido ao clima quente na costa leste, a primavera chegou no início deste ano. Muito provavelmente, minha alergia acabou.

Mas os sintomas não melhoraram o dia todo.

E aqui estou eu sentado aqui, escrevendo este manual com um termômetro na boca; e olhando para baixo mostra 37,4 ° C. A temperatura está mais alta do que meus 36,3 ° C habituais. Tudo acima de 37,2 ° C, eu já considero uma febre leve.

Tosse e um pouco de febre? Pode ser COVID-19 ... ou apenas minha alergia.

É impossível descobrir sem um teste, e é exatamente essa "ignorância" que torna essa situação tão perigosa para o equilíbrio mental.

Para as pessoas não há nada mais terrível que o desconhecido.

Apesar de todos os medos, tento me livrar deles de uma maneira racional. Tenho mais de trinta anos, estou em ótima forma, meu sistema imunológico é muito forte. Vou para a quarentena (só por precaução), vou descansar e me recuperar normalmente. O COVID-19 não me assusta em termos de saúde pessoal (pelo menos continuo dizendo isso para mim mesmo).

No entanto, eu me preocupo com meus parentes idosos, incluindo aqueles que têm doenças crônicas e aqueles em um lar de idosos ou hospital. Eles são vulneráveis ​​e será realmente triste se os perdermos devido a esta infecção.

Para não me sentar e não sucumbir à fraqueza (seja alergia, COVID-19 ou apenas ansiedade), decidi fazer o que faço de melhor -atenda a toda a comunidade de visão de máquina e aprendizado profundo escrevendo código, realizando experimentos e ensinando outras pessoas a usar a visão computacional e o aprendizado profundo em aplicações práticas do mundo real .

No entanto, para ser sincero, este não é o artigo mais científico que já escrevi. De fato, longe de ser o mais. Os métodos e conjuntos de dados usados ​​não merecem publicação. Mas eles podem ser o ponto de partida para quem quer ajudar.

Mas eu quero fazer tudo ao meu alcance. Este artigo é simplesmente minha maneira de superar mentalmente momentos difíceis e, ao mesmo tempo, ajudar outras pessoas em uma situação semelhante.

Eu espero que você me entenda.

Na lição de hoje, faremos o seguinte:

  1. Coletaremos um conjunto de dados abertos de fluorogramas de pacientes com teste positivo para COVID-19.
  2. Coletamos uma seleção de fluorogramas de pacientes saudáveis.
  3. Treinaremos a rede neural convolucional para detectar automaticamente o COVID-19 nas imagens do conjunto criado.
  4. Avaliaremos os resultados obtidos do ponto de vista educacional.

Isenção de responsabilidade: eu já sugeri, mas vou dizer sem rodeios. Os métodos e técnicas deste artigo são apenas para fins educacionais. Este não é um estudo científico real e não será publicado em uma revista. O artigo é destinado a leitores interessados ​​em (1) visão computacional / aprendizado profundo e que desejam aprender usando métodos práticos e (2) estão preocupados com os eventos atuais. Eu imploro que você se relacione com isso dessa maneira.

COVID-19 em fluorogramas


Na primeira parte, discutiremos como o COVID-19 pode ser detectado nas radiografias de tórax.

Em seguida, considere nosso conjunto de dados.

Em seguida, mostrarei como treinar o modelo de aprendizado profundo usando Keras e TensorFlow para definir COVID-19 em nosso conjunto de dados de imagens.

Minha tarefa é inspirá-lo e mostrar que o estudo da visão computacional / aprendizado profundo e a aplicação desse conhecimento na área médica podem ter um grande impacto no mundo.

Simplificando: você não precisa de um diploma médico para contribuir com a medicina. Especialistas em aprendizado profundo que trabalham em estreita colaboração com médicos e profissionais de saúde podem resolver problemas complexos, salvar vidas e tornar o mundo um lugar melhor.

Espero que este guia o inspire a fazer exatamente isso.

Mas com tudo isso dito, as revistas científicas e os sistemas de avaliação de especialistas estão cheios de materiais com modelos de previsão do COVID-19 de qualidade duvidosa. Não pegue o código / modelo deste artigo e não o envie para a revista ou coloque-o em domínio público em sites científicos - você apenas adicionará algum ruído.

Além disso, se você pretende usar este artigo (ou qualquer outro artigo da COVID-19 da Internet) em sua própria pesquisa, verifique as regras do TRIPOD para criar modelos de relatórios de previsão .

Como você provavelmente sabe, o uso da IA ​​na medicina leva a consequências muito reais . Publique ou use esses modelos somente após consulta cuidadosa com um médico especialista.


FIG. 1. Um exemplo de fluorograma de um paciente com teste positivo para COVID-19. Usando Keras e TensorFlow nessas imagens, é possível treinar o classificador para detectar COVID-19. Atualmente, os

testes COVID-19 são difíceis de encontrar - eles simplesmente não são suficientes e não podem ser feitos com rapidez, o que causa pânico.

Quando há pânico, algumas pessoas vil aproveitam isso e vendem kits de teste COVID-19 falsos , encontrando vítimas em redes sociais e mensageiros instantâneos .

Como o número de kits de teste COVID-19 é limitado, você deve confiar em outros métodos de diagnóstico.

Os médicos costumam confiar nas radiografias do tórax (comumente chamadas fluorogramas) para diagnosticar pneumonia, pneumonia, abscessos e / ou linfonodos aumentados.

O COVID-19 ataca o epitélio do trato respiratório e os raios X ajudam a examinar a condição pulmonar do paciente. As máquinas de raio-X são instaladas na maioria dos hospitais; portanto, é lógico usar a fluorografia para testar o COVID-19 sem kits de teste especiais. A desvantagem é que essa análise requer um especialista em radiologia e leva um tempo considerável. Portanto, o desenvolvimento de um sistema automatizado será muito valioso para economizar o tempo valioso de profissionais médicos em todo o mundo.

Nota. Algumas publicações mais recentes sugerem que a tomografia computadorizada é melhor para o diagnóstico do COVID-19, mas nesta lição trabalhamos apenas com fluorogramas.

Conjunto de dados



FIG. 2. À esquerda, amostras positivas (de pacientes infectados) e à direita, negativas. Essas imagens são usadas para treinar um modelo para prever automaticamente a presença de uma doença.O

nosso conjunto de dados foi compilado pelo Dr. Joseph Cohen , um estudante de graduação da Universidade de Montreal. No início de março, ele começou a coletar fluorogramas de pacientes com COVID-19, MERS, SARS e SARS e publicá-los no repositório no GitHub .

Precisamos baixar um arquivo do repositóriometadata.csve selecionar as linhas onde é indicado

  1. Resultado positivo em COVID-19.
  2. Tipo de pulmão 'posterior-anterior' (AP). Pelo que entendi, esse é o tipo de imagem usada em imagens "saudáveis".

Um total de 25 fluorogramas foi encontrado com casos positivos de COVID-19 (Fig. 2, à esquerda).

Para pacientes saudáveis, usei o conjunto de dados Cuggle (pneumonia) e selecionei 25 imagens de pacientes saudáveis ​​(Fig. 2, à direita). Esse conjunto de dados apresenta vários problemas, como etiquetas com ruído / incorretos, mas serve para uma verificação conceitual do detector automático COVID-19.

Estrutura do projeto


Na seção Downloads do meu site, você pode inserir seu endereço de e-mail e descobrir um link para o arquivo com código, scripts e outros arquivos para este projeto. Extraia os arquivos e você verá a estrutura de diretórios:

$ tree --dirsfirst --filelimit 10
.
├── dataset
│   ├── covid [25 entries]
│   └── normal [25 entries]
├── build_covid_dataset.py
├── sample_kaggle_dataset.py
├── train_covid19.py
├── plot.png
└── covid19.model
3 directories, 5 files

Os fluorogramas estão em um diretório em dataset/que duas classes de dados são divididas em diretórios covid/e normal/.

Ambos os scripts são apresentados para a construção de um conjunto de dados, mas não os consideraremos hoje. Em vez disso, considere um script train_covid19.pyque ensina nosso detector COVID-19.

Implementação


Vamos seguir para a criação de uma rede neural convolucional. Abra o arquivo train_covid19.pye cole o seguinte código:

# import the necessary packages
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import VGG16
from tensorflow.keras.layers import AveragePooling2D
from tensorflow.keras.layers import Dropout
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Input
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from imutils import paths
import matplotlib.pyplot as plt
import numpy as np
import argparse
import cv2
import os

Esse script usa várias bibliotecas de aprendizado profundo do TensorFlow 2.0 e Keras. Além disso, usamos o scikit-learn , a biblioteca padrão do Python para aprendizado de máquina, o matplotlib para gráficos e o OpenCV para carregar e processar imagens.

Para instalar o TensorFlow 2.0 (incluindo as bibliotecas apropriadas scikit-learn, OpenCV e matplotlib), basta seguir minhas instruções para Ubuntu ou macOS .

A seguir, analisaremos os argumentos da linha de comando e inicializaremos os hiperparâmetros:

# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-d", "--dataset", required=True,
	help="path to input dataset")
ap.add_argument("-p", "--plot", type=str, default="plot.png",
	help="path to output loss/accuracy plot")
ap.add_argument("-m", "--model", type=str, default="covid19.model",
	help="path to output loss/accuracy plot")
args = vars(ap.parse_args())
# initialize the initial learning rate, number of epochs to train for,
# and batch size
INIT_LR = 1e-3
EPOCHS = 25
BS = 8

Três argumentos de linha de comando :

  • --dataset: caminho para o conjunto de dados de entrada
  • --plot: Um caminho opcional para a programação de saída do seu histórico de aprendizado. Salvo indicação em contrário, o padrão éplot.png
  • --model: caminho opcional para o modelo de saída; padrãocovid19.model

As próximas linhas inicializam a velocidade inicial de aprendizado, o número de eras e os hiperparâmetros do tamanho do pacote.

Agora estamos prontos para baixar e pré-processar os fluorogramas:

# grab the list of images in our dataset directory, then initialize
# the list of data (i.e., images) and class images
print("[INFO] loading images...")
imagePaths = list(paths.list_images(args["dataset"]))
data = []
labels = []
# loop over the image paths
for imagePath in imagePaths:
	# extract the class label from the filename
	label = imagePath.split(os.path.sep)[-2]
	# load the image, swap color channels, and resize it to be a fixed
	# 224x224 pixels while ignoring aspect ratio
	image = cv2.imread(imagePath)
	image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
	image = cv2.resize(image, (224, 224))
	# update the data and labels lists, respectively
	data.append(image)
	labels.append(label)
# convert the data and labels to NumPy arrays while scaling the pixel
# intensities to the range [0, 1]
data = np.array(data) / 255.0
labels = np.array(labels)

Para carregar dados, capturamos todos os caminhos para as imagens no catálogo --dataset. Depois, para cada um imagePath:

  • Recuperamos o rótulo da classe ( covidou normal) do caminho .
  • Nós o carregamos imagee pré-processamos, convertendo-o em RGB e redimensionando para 224 × 224 pixels, para que esteja pronto para a rede neural.
  • Atualizando listas datae labels.

Em seguida, redimensione a intensidade do pixel para o intervalo [0, 1] e converta os dados e os rótulos no formato de matriz NumPy.

Em seguida, executamos a codificação direta labelsdividindo os dados em conjuntos para treinamento / teste:

# perform one-hot encoding on the labels
lb = LabelBinarizer()
labels = lb.fit_transform(labels)
labels = to_categorical(labels)
# partition the data into training and testing splits using 80% of
# the data for training and the remaining 20% for testing
(trainX, testX, trainY, testY) = train_test_split(data, labels,
	test_size=0.20, stratify=labels, random_state=42)
# initialize the training data augmentation object
trainAug = ImageDataGenerator(
	rotation_range=15,
	fill_mode="nearest")

Codificação direta significa que os dados são convertidos no seguinte formato:

[[0. 1.]
 [0. 1.]
 [0. 1.]
 ...
 [1. 0.]
 [1. 0.]
 [1. 0.]]

Cada etiqueta codificada consiste em uma matriz com dois elementos: 'hot' (1) ou 'not' (0).

As linhas a seguir separam nossos dados, deixando 80% para treinamento e 20% para teste.

Para garantir que o modelo seja generalizado, realizamos o aumento dos dados configurando a imagem para girar aleatoriamente 15 ° no sentido horário ou anti-horário.

As últimas três linhas inicializam o objeto gerador de aumento de dados.

Agora, inicialize nosso modelo VGGNet e ajuste-o :

# load the VGG16 network, ensuring the head FC layer sets are left
# off
baseModel = VGG16(weights="imagenet", include_top=False,
	input_tensor=Input(shape=(224, 224, 3)))
# construct the head of the model that will be placed on top of the
# the base model
headModel = baseModel.output
headModel = AveragePooling2D(pool_size=(4, 4))(headModel)
headModel = Flatten(name="flatten")(headModel)
headModel = Dense(64, activation="relu")(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(2, activation="softmax")(headModel)
# place the head FC model on top of the base model (this will become
# the actual model we will train)
model = Model(inputs=baseModel.input, outputs=headModel)
# loop over all layers in the base model and freeze them so they will
# *not* be updated during the first training process
for layer in baseModel.layers:
	layer.trainable = False

As duas primeiras linhas criam uma instância da rede VGG16 com pesos previamente treinados no ImageNet sem tocar na camada totalmente conectada (FC).

Em seguida, criamos uma nova camada totalmente conectada, composta por camadas POOL => FC = SOFTMAX, e a adicionamos ao VGG16.

Em seguida, congelamos os pesos CONVpara o VGG16, para que apenas a camada FC seja treinada . Isso completa a instalação.

Agora estamos prontos para compilar e treinar nosso modelo de aprendizado profundo para o COVID-19:

# compile our model
print("[INFO] compiling model...")
opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
model.compile(loss="binary_crossentropy", optimizer=opt,
	metrics=["accuracy"])
# train the head of the network
print("[INFO] training head...")
H = model.fit_generator(
	trainAug.flow(trainX, trainY, batch_size=BS),
	steps_per_epoch=len(trainX) // BS,
	validation_data=(testX, testY),
	validation_steps=len(testX) // BS,
	epochs=EPOCHS)

As primeiras linhas compilam a rede neural com a opção de reduzir a velocidade de aprendizado e o otimizador Adam. Dado que este é um problema de duas classes, usamos perda em "binary_crossentropy"vez de entropia cruzada.

Para iniciar o processo de aprendizado, chamamos o método fit_generator em Keras , passando os fluorogramas pelo nosso objeto de aumento de dados.

Avaliamos o modelo:

# make predictions on the testing set
print("[INFO] evaluating network...")
predIdxs = model.predict(testX, batch_size=BS)
# for each image in the testing set we need to find the index of the
# label with corresponding largest predicted probability
predIdxs = np.argmax(predIdxs, axis=1)
# show a nicely formatted classification report
print(classification_report(testY.argmax(axis=1), predIdxs,
	target_names=lb.classes_))

Para avaliar, primeiro fazemos previsões no conjunto de testes, preservando os índices de previsão. Em seguida, criamos e exibimos um relatório de classificação usando o scikit-learn, onde existe uma função auxiliar.

Em seguida, calculamos a matriz de imprecisões para posterior avaliação estatística:

# compute the confusion matrix and and use it to derive the raw
# accuracy, sensitivity, and specificity
cm = confusion_matrix(testY.argmax(axis=1), predIdxs)
total = sum(sum(cm))
acc = (cm[0, 0] + cm[1, 1]) / total
sensitivity = cm[0, 0] / (cm[0, 0] + cm[0, 1])
specificity = cm[1, 1] / (cm[1, 0] + cm[1, 1])
# show the confusion matrix, accuracy, sensitivity, and specificity
print(cm)
print("acc: {:.4f}".format(acc))
print("sensitivity: {:.4f}".format(sensitivity))
print("specificity: {:.4f}".format(specificity))

Aqui fazemos o seguinte:

  • Geramos uma matriz de imprecisões.
  • Com sua ajuda, calculamos a precisão, a sensibilidade e a especificidade, imprimindo todas essas métricas.

Para o autoteste, geramos um gráfico com um histórico de precisão e perdas de treinamento e o enviamos para um arquivo gráfico:

# plot the training loss and accuracy
N = EPOCHS
plt.style.use("ggplot")
plt.figure()
plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
plt.plot(np.arange(0, N), H.history["accuracy"], label="train_acc")
plt.plot(np.arange(0, N), H.history["val_accuracy"], label="val_acc")
plt.title("Training Loss and Accuracy on COVID-19 Dataset")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend(loc="lower left")
plt.savefig(args["plot"])

Por fim, salve o modelo do classificador tf.kerasem disco:

# serialize the model to disk
print("[INFO] saving COVID-19 detector model...")
model.save(args["model"], save_format="h5")

Treinamento de detectores


Depois de baixar todos os arquivos do arquivo morto com as fontes e scripts mencionados acima, abra o console e execute o seguinte comando para treinar o detector:

$ python train_covid19.py --dataset dataset
[INFO] loading images...
[INFO] compiling model...
[INFO] training head...
Epoch 1/25
5/5 [==============================] - 20s 4s/step - loss: 0.7169 - accuracy: 0.6000 - val_loss: 0.6590 - val_accuracy: 0.5000
Epoch 2/25
5/5 [==============================] - 0s 86ms/step - loss: 0.8088 - accuracy: 0.4250 - val_loss: 0.6112 - val_accuracy: 0.9000
Epoch 3/25
5/5 [==============================] - 0s 99ms/step - loss: 0.6809 - accuracy: 0.5500 - val_loss: 0.6054 - val_accuracy: 0.5000
Epoch 4/25
5/5 [==============================] - 1s 100ms/step - loss: 0.6723 - accuracy: 0.6000 - val_loss: 0.5771 - val_accuracy: 0.6000
...
Epoch 22/25
5/5 [==============================] - 0s 99ms/step - loss: 0.3271 - accuracy: 0.9250 - val_loss: 0.2902 - val_accuracy: 0.9000
Epoch 23/25
5/5 [==============================] - 0s 99ms/step - loss: 0.3634 - accuracy: 0.9250 - val_loss: 0.2690 - val_accuracy: 0.9000
Epoch 24/25
5/5 [==============================] - 27s 5s/step - loss: 0.3175 - accuracy: 0.9250 - val_loss: 0.2395 - val_accuracy: 0.9000
Epoch 25/25
5/5 [==============================] - 1s 101ms/step - loss: 0.3655 - accuracy: 0.8250 - val_loss: 0.2522 - val_accuracy: 0.9000
[INFO] evaluating network...
              precision    recall  f1-score   support
       covid       0.83      1.00      0.91         5
      normal       1.00      0.80      0.89         5
    accuracy                           0.90        10
   macro avg       0.92      0.90      0.90        10
weighted avg       0.92      0.90      0.90        10
[[5 0]
 [1 4]]
acc: 0.9000
sensitivity: 1.0000
specificity: 0.8000
[INFO] saving COVID-19 detector model...

Diagnóstico automático de COVID-19 de acordo com os resultados da fluorografia


: , «» COVID-19. . , , , ( , ). , / COVID-19.

Como pode ser visto pelos resultados acima, nosso detector automático tem uma precisão de cerca de 90 a 92% em um conjunto de amostras existente. Esta classificação é baseada apenas na análise de imagem. Durante o treinamento, não foram utilizados mais dados, incluindo localização geográfica, densidade populacional etc.

A sensibilidade foi de 100% e a especificidade de 80%, o que significa:

  • Pacientes verdadeiramente infectados são reconhecidos em 100% dos casos.
  • Pacientes saudáveis ​​são reconhecidos como saudáveis, com uma probabilidade de 80%.

Como mostra o gráfico do histórico de treinamento, nossa rede não é muito treinada, apesar de um conjunto de dados muito limitado : a



capacidade de reconhecer o COVID-19 com precisão absoluta é ótima, embora a taxa de falsos positivos seja um pouco preocupante, porque muitas pessoas saudáveis ​​serão enviadas para quarentena com pacientes realmente infectados.

Equilibrar sensibilidade e especificidade é incrivelmente difícil quando se trata de aplicações médicas, especialmente no caso de doenças infecciosas.

Quando se trata de visão computacional e treinamento profundo em medicina, lembre-se sempre de que nossos modelos preditivos podem ter consequências muito reais - um diagnóstico perdido pode custar a vida.

Novamente, esses resultados são coletados apenas para fins educacionais. Este artigo e os resultados que o acompanham não se destinam à publicação em uma revista científica e não estão em conformidade com as regras do TRIPOD para a criação de modelos de relatórios de previsão .

Limitações, melhorias e trabalhos futuros



FIG. 4. Atualmente, especialistas em inteligência artificial (IA) e especialistas em aprendizado profundo sofrem com a falta de dados de qualidade para o treinamento eficaz dos sistemas de detecção automática COVID-19 em imagens ( fonte da imagem ).

Uma das principais limitações para a criação desses sistemas são os dados. Simplesmente não temos dados suficientes (confiáveis) para treinar o detector COVID-19. Os hospitais estão lotados de pacientes com COVID-19, mas, devido a seus direitos e privacidade, está se tornando ainda mais difícil coletar conjuntos de imagens médicas de qualidade em tempo hábil.

Suponho que nos próximos 12 a 18 meses o problema será resolvido, mas por enquanto estamos satisfeitos com o que temos. Fiz o meu melhor (considerando minha atual condição mental e física) para compilar um guia para aqueles que estão interessados ​​em usar a visão computacional e o aprendizado profundo na luta contra o COVID-19, levando em consideração as limitações de tempo e recursos. Mas devo lembrá-lo de que não sou especialista em medicina.

Um verdadeiro detector COVID-19 deve ser submetido a testes rigorosos por profissionais médicos treinados, trabalhando lado a lado com profissionais experientes em aprendizado profundo. O método descrito aqui, é claro, não é adequado para uso prático e destina-se apenas a fins educacionais.

Além disso, devemos nos perguntar o que esse modelo realmente “aprende”. Como eu disse empelo guia Grad-CAM na semana passada, é perfeitamente possível que nosso modelo estude padrões que não estejam relacionados ao COVID-19, mas simplesmente sejam variações entre dois conjuntos de dados (ou seja, entre pacientes com e sem COVID-19). Para confirmar os resultados, são necessários testes completos e assistência especializada.

Finalmente, os futuros (e melhores) detectores serão multimodais.

Agora, consideramos apenas imagens (por exemplo, raios-x). Os melhores detectores automáticos COVID-19 devem usar várias fontes de dados, não limitadas a imagens, incluindo indicadores vitais do paciente, densidade populacional, localização geográfica, etc. As imagens por si só geralmente não são suficientes para esse tipo de aplicação.

Espero que este guia sirva como ponto de partida para qualquer pessoa interessada em usar visão computacional e aprendizado profundo para detectar automaticamente o COVID-19.

Qual é o próximo?


Normalmente, termino meus artigos de blog com uma recomendação de um dos meus livros ou cursos para que você possa aprender mais sobre o uso da visão computacional e do aprendizado profundo. Por respeito à seriedade do coronavírus, não vou fazer isso - agora não é a hora nem o lugar.

Em vez disso, direi que agora estamos em um período de vida muito terrível. Como as estações do ano, tudo vai passar, mas por enquanto você precisa se agachar e se preparar para o inverno frio - é provável que o pior ainda esteja por vir.

Recebi várias cartas dos leitores do PyImageSearch que desejam usar esse tempo de inatividade para estudar a visão por computador e o aprendizado profundo, em vez de enlouquecer em suas casas. Este é um pensamento útil.

Sumário


Neste guia, você aprendeu como usar o Keras e o TensorFlow para treinar o detector automático COVID-19 em um conjunto de fluorogramas.

Ainda não existem conjuntos de dados de imagem de alta qualidade e revisados ​​por pares para o COVID-19, portanto tivemos que trabalhar com o que tínhamos, a saber, o repositório de Joseph Cohen no GitHub :


Usamos o Keras e o TensorFlow para treinar o detector COVID-19, que demonstra precisão de 90 a 92%, sensibilidade de 100% e especificidade de 80% no conjunto de testes (dado nosso conjunto de dados limitado).

Lembre-se de que o detector COVID-19 descrito é apenas para fins educacionais.

More articles:


All Articles