Machine learning intelligent medical imaging new coronary pneumonia virus detection

Editor: The data science team of DataComo has been engaged in the field of data fusion for a long time. After the spread of the new crown epidemic, it perfectly solved the problem of trajectory analysis of close contacts: through mobile phone base stations or Wi-Fi signals , Can accurately analyze the trajectory and contact time of the communicator and the close contact, and millions of users can get the analysis result within tens of seconds.

Now we are committed to adopting advanced image analysis algorithms and working with a team of medical experts to establish intelligent image monitoring and diagnostic tools based on machine learning, providing valuable and reliable online second-line services for community hospitals, third world countries, and grassroots hospitals. Medical opinion.

The novel coronavirus pneumonia (COVID-19) is a new type of human disease discovered in 2019, and there is no precedent to follow. Coronavirus is a huge family of viruses, which can cause patients to develop symptoms of varying severity, ranging from the common cold to severe acute respiratory syndrome, such as Middle East Respiratory Syndrome (MERS-COV) or severe acute respiratory syndrome (SARS- COV). The pneumonia has caused a global pandemic. At present, a large number of people are infected and receiving treatment all over the world. In the United States alone, the COVID-19 epidemic may cause 160 million to 214 million people to be infected. Some countries and regions have declared a state of emergency, with as many as millions of people in quarantine. Testing and diagnostic tools can provide doctors with valuable second diagnosis and treatment opinions and assist them in completing screening. At the same time, such a mechanism also helps to quickly present the test results to the doctor.

◆ ◆ ◆ ◆

Load data set

First, use imageDatastore to load the database. This function is used to load images and their tags to perform analysis, and has high computational efficiency.

%Clear workspace
clear; close all; clc;

%ImagesDatapath–Please modify your path accordingly
datapath='dataset';

%ImageDatastore
imds=imageDatastore(datapath,...
'IncludeSubfolders',true,...'LabelSource','foldernames');
%Determine the split up
total_split=countEachLabel(imds)

Image visualization

Visualize the images to understand the differences between the images. In addition, it also helps us determine which classification method to use to distinguish the two categories. According to the image, we can choose the appropriate preprocessing technology to help us complete the classification. According to the similarity within the class and the difference between the classes, we can determine the type of CNN architecture required for the research.

%Number of Imagesnum_images=length(imds.Labels);

%Visualize random images
perm=randperm(num_images,6);figure;
for idx=1:length(perm)

    subplot(2,3,idx);
    imshow(imread(imds.Files{perm(idx)}));
    title(sprintf('%s',imds.Labels(perm(idx))))

end

In order to simplify the classification process of the deep learning architecture, we applied a simple preprocessing technique, and the functions used are shown at the end of the article.

K-fold verification

As mentioned above, the number of images provided by this data set is limited, so we split the data set into 10 folds for analysis, that is, use each group of images in the data set to train 10 different algorithms. This verification method provides a more accurate performance estimate than the commonly used leave-out verification method. This article uses the ResNet-50 architecture because it has proven to be very effective for various medical imaging applications [1,2].

%Number of foldsnum_folds=10;

%Loopfor each foldfor fold_idx=1:num_folds

    fprintf

    fprintf('Processing %d among %d folds \n',fold_idx,num_folds);

%TestIndicesfor current fold
    test_idx=fold_idx:num_folds:num_images;

%Test cases for current fold
    imdsTest = subset(imds,test_idx);

%Train indices for current fold
    train_idx=setdiff(1:length(imds.Files),test_idx);

%Train cases for current fold
    imdsTrain = subset(imds,train_idx);

%ResNetArchitecture
    net=resnet50;
    lgraph = layerGraph(net);
    clear net;

%Number of categories
    numClasses = numel(categories(imdsTrain.Labels));

%NewLearnableLayer
    newLearnableLayer = fullyConnectedLayer(numClasses,...
'Name','new_fc',...
'WeightLearnRateFactor',10,...
'BiasLearnRateFactor',10);

%Replacing the last layers withnew layers
    lgraph = replaceLayer(lgraph,'fc1000',newLearnableLayer);
    newsoftmaxLayer = softmaxLayer('Name','new_softmax');
    lgraph = replaceLayer(lgraph,'fc1000_softmax',newsoftmaxLayer);
    newClassLayer = classificationLayer('Name','new_classoutput');
    lgraph = replaceLayer(lgraph,'ClassificationLayer_fc1000',newClassLayer);


%PreprocessingTechnique
    imdsTrain.ReadFcn=@(filename)preprocess_Xray(filename);
    imdsTest.ReadFcn=@(filename)preprocess_Xray(filename);

%TrainingOptions, we choose a small mini-batch size due to limited images
    options = trainingOptions('adam',...
'MaxEpochs',30,'MiniBatchSize',8,...
'Shuffle','every-epoch',...
'InitialLearnRate',1e-4,...
'Verbose',false,...
'Plots','training-progress');

%DataAugumentation
    augmenter = imageDataAugmenter(...
'RandRotation',[-55],'RandXReflection',1,...
'RandYReflection',1,'RandXShear',[-0.050.05],'RandYShear',[-0.050.05]);

%Resizing all training images to [224224]forResNet architecture
    auimds = augmentedImageDatastore([224224],imdsTrain,'DataAugmentation',augmenter);

%Training
    netTransfer = trainNetwork(auimds,lgraph,options);

%Resizing all testing images to [224224]forResNet architecture
    augtestimds = augmentedImageDatastore([224224],imdsTest);

%Testingand their corresponding LabelsandPosteriorfor each Case
[predicted_labels(test_idx),posterior(test_idx,:)]= classify(netTransfer,augtestimds);

%Save the IndependentResNetArchitectures obtained for each Fold
    save(sprintf('ResNet50_%d_among_%d_folds',fold_idx,num_folds),'netTransfer','test_idx','train_idx');

%Clearing unnecessary variables
    clearvars -except fold_idx num_folds num_images predicted_labels posterior imds netTransfer;

end

Performance study

We measure the performance of the algorithm through a confusion matrix, which also reflects the performance in terms of precision and recall. We believe that overall accuracy is an effective indicator because the test data set used in this study is uniformly distributed (the number of images in each category is equal).

Confusion matrix

%ActualLabelsactual_labels=imds.Labels;

%ConfusionMatrix
figure;
plotconfusion(actual_labels,predicted_labels')
title('ConfusionMatrix:ResNet');

ROC curve

ROC assists doctors in selecting work points based on false alarm rates and detection rates.

test_labels=double(nominal(imds.Labels));

% ROC Curve-Our target classis the first classinthis scenario [fp_rate,tp_rate,T,AUC]=perfcurve(test_labels,posterior(:,1),1);
figure;
plot(fp_rate,tp_rate,'b-');
grid on;
xlabel('False Positive Rate');
ylabel('Detection Rate');

%Area under the ROC curve value

AUC

AUC = 0.9776

Class activation mapping

Use the following code to visualize the class activation mapping (CAM) results obtained after different COVID-19 cases are processed by these networks: https://www.mathworks.com/help/deeplearning/examples/investigate-network-predictions-using- class-activation-mapping.html. This helps doctors understand the basis behind algorithmic decisions. The following are the corresponding results of different cases:

Test based on other public data sets

In order to further study and analyze the performance of the algorithm, we need to determine the probability of detecting COVID-19 from other public data sets that do not contain COVID-19 tags. Here, we use the cases provided by [2], which were marked by the radiologist as normal, bacterial pneumonia, or viral pneumonia. As mentioned above, each network uses a different set of images in the COVID-19 data set for training. As long as the posterior probability of the coronavirus in an image is greater than 0.5, it is considered a false positive (FP). The results clearly show that our algorithm has high specificity and sensitivity. On a single-core GPU, each test case takes about 13 milliseconds.

in conclusion

This article introduces a simple classification method based on deep learning that can be used for computer-aided diagnosis of COVID-19. The classification algorithm based on ResNet performs relatively well, with high overall accuracy and AUC. The good performance of the transfer learning method once again confirms that the CNN-based classification model is suitable for feature extraction. The algorithm can be easily retrained using a few new sets of labeled images to further enhance performance. Combining the above results with other existing architectures can improve performance from both AUC and overall accuracy. If we can comprehensively study these algorithms in terms of computational capacity (memory and time) and performance, it will help relevant experts to select algorithms with emphasis. Computer-aided diagnosis is not only a good helper for doctors in COVID-19 screening, but also helps provide valuable second diagnosis and treatment opinions.

◆ ◆ ◆ ◆

references

[1] Narayanan, B. N., De Silva, M. S., Hardie, R. C., Kueterman, N. K., & Ali, R. (2019). "Understanding Deep Neural Network Predictions for Medical Imaging Applications". arXiv preprint arXiv:1912.09621.

[2] Narayanan, BN, Davuluru, VSP, & Hardie, RC (2020, March)."Two-stage deep learning architecture for pneumonia detection and its diagnosis in chest radiographs".In Medical Imaging 2020:Imaging Informatics for Healthcare, Research , and Applications (Vol. 11318, p. 113180G). International Society for Optics and Photonics.

Preprocessing function

function Iout= preprocess_Xray(filename)
%Thisfunction preprocesses the given X-ray image by converting it into
% grayscale if required and later converting to 3-channel image to adapt to
% existing deep learning architectures
%
%Author:BarathNarayanan
%Date:3/17/2020

%Read the Filename
I = imread(filename);

%Some images might be RGB, convert them to Grayscale
if ~ismatrix(I)
    I=rgb2gray(I);
end

%Replicate the image 3 times to create an RGB image
Iout= cat(3,I,I,I);

end