使用深度学习检测疟疾，深度检测疟疾


人工智能结合开源硬件工具能够提升严重传染病疟疾的诊断。

人工智能（AI）和开源工具、技术和框架是促进社会进步的强有力的结合。“健康就是财富”可能有点陈词滥调，但它却是非常准确的！在本篇文章，我们将测试 AI 是如何与低成本、有效、精确的开源深度学习方法结合起来一起用来检测致死的传染病疟疾。

我既不是一个医生，也不是一个医疗保健研究者，我也绝不像他们那样合格，我只是对将 AI 应用到医疗保健研究感兴趣。在这片文章中我的想法是展示 AI 和开源解决方案如何帮助疟疾检测和减少人工劳动的方法。

Python 和 TensorFlow: 一个构建开源深度学习方法的很棒的结合

感谢 Python 的强大和像 TensorFlow 这样的深度学习框架，我们能够构建健壮的、大规模的、有效的深度学习方法。因为这些工具是自由和开源的，我们能够构建非常经济且易于被任何人采纳和使用的解决方案。让我们开始吧！

项目动机

疟疾是由疟原虫造成的致死的、有传染性的、蚊子传播的疾病，主要通过受感染的雌性按蚊叮咬传播。共有五种寄生虫能够引起疟疾，但是大多数病例是这两种类型造成的：恶性疟原虫和间日疟原虫。

疟疾热图

这个地图显示了疟疾在全球传播分布形势，尤其在热带地区，但疾病的性质和致命性是该项目的主要动机。

如果一只受感染雌性蚊子叮咬了你，蚊子携带的寄生虫进入你的血液，并且开始破坏携带氧气的红细胞（RBC）。通常，疟疾的最初症状类似于流感病毒，在蚊子叮咬后，他们通常在几天或几周内发作。然而，这些致死的寄生虫可以在你的身体里生存长达一年并且不会造成任何症状，延迟治疗可能造成并发症甚至死亡。因此，早期的检查能够挽救生命。

世界健康组织（WHO）的疟疾实情表明，世界近乎一半的人口面临疟疾的风险，有超过 2 亿的疟疾病例，每年由于疟疾造成的死亡将近 40 万。这是使疟疾检测和诊断快速、简单和有效的一个动机。

检测疟疾的方法

有几种方法能够用来检测和诊断疟疾。该文中的项目就是基于 Rajaraman, et al. 的论文：“预先训练的卷积神经网络作为特征提取器，用于改善薄血涂片图像中的疟疾寄生虫检测”介绍的一些方法，包含聚合酶链反应（PCR）和快速诊断测试（RDT）。这两种测试通常用于无法提供高质量显微镜服务的地方。

标准的疟疾诊断通常是基于血液涂片工作流程的，根据 Carlos Ariza 的文章“Malaria Hero：一个更快诊断疟原虫的网络应用”，我从中了解到 Adrian Rosebrock 的“使用 Keras 的深度学习和医学图像分析”。我感激这些优秀的资源的作者，让我在疟原虫预防、诊断和治疗方面有了更多的想法。

一个疟原虫检测的血涂片工作流程

根据 WHO 方案，诊断通常包括对放大 100 倍的血涂片的集中检测。受过训练的人们手工计算在 5000 个细胞中有多少红细胞中包含疟原虫。正如上述解释中引用的 Rajaraman， et al. 的论文：

厚血涂片有助于检测寄生虫的存在，而薄血涂片有助于识别引起感染的寄生虫种类（疾病控制和预防中心, 2012）。诊断准确性在很大程度上取决于诊断人的专业知识，并且可能受到观察者间差异和疾病流行/资源受限区域大规模诊断所造成的不利影响（Mitiku, Mengistu 和 Gelaw, 2003）。可替代的技术是使用聚合酶链反应（PCR）和快速诊断测试（RDT）；然而，PCR 分析受限于它的性能（Hommelsheim, et al., 2014），RDT 在疾病流行的地区成本效益低（Hawkes, Katsuva 和 Masumbuko, 2009）。

因此，疟疾检测可能受益于使用机器学习的自动化。

疟疾检测的深度学习

人工诊断血涂片是一个繁重的手工过程，需要专业知识来分类和计数被寄生虫感染的和未感染的细胞。这个过程可能不能很好的规模化，尤其在那些专业人士不足的地区。在利用最先进的图像处理和分析技术提取人工选取特征和构建基于机器学习的分类模型方面取得了一些进展。然而，这些模型不能大规模推广，因为没有更多的数据用来训练，并且人工选取特征需要花费很长时间。

深度学习模型，或者更具体地讲，卷积神经网络（CNN），已经被证明在各种计算机视觉任务中非常有效。（如果你想更多的了解关于 CNN 的背景知识，我推荐你阅读视觉识别的 CS2331n 卷积神经网络。）简单地讲，CNN 模型的关键层包含卷积和池化层，正如下图所示。

一个典型的 CNN 架构

卷积层从数据中学习空间层级模式，它是平移不变的，因此它们能够学习图像的不同方面。例如，第一个卷积层将学习小的和局部图案，例如边缘和角落，第二个卷积层将基于第一层的特征学习更大的图案，等等。这允许 CNN 自动化提取特征并且学习对于新数据点通用的有效的特征。池化层有助于下采样和减少尺寸。

因此，CNN 有助于自动化和规模化的特征工程。同样，在模型末尾加上密集层允许我们执行像图像分类这样的任务。使用像 CNN 这样的深度学习模型自动的疟疾检测可能非常有效、便宜和具有规模性，尤其是迁移学习和预训练模型效果非常好，甚至在少量数据的约束下。

Rajaraman, et al. 的论文在一个数据集上利用六个预训练模型在检测疟疾对比无感染样本获取到令人吃惊的 95.9% 的准确率。我们的重点是从头开始尝试一些简单的 CNN 模型和用一个预训练的训练模型使用迁移学习来查看我们能够从相同的数据集中得到什么。我们将使用开源工具和框架，包括 Python 和 TensorFlow，来构建我们的模型。

数据集

我们分析的数据来自 Lister Hill 国家生物医学交流中心（LHNCBC）的研究人员，该中心是国家医学图书馆（NLM）的一部分，他们细心收集和标记了公开可用的健康和受感染的血涂片图像的数据集。这些研究者已经开发了一个运行在 Android 智能手机的疟疾检测手机应用，连接到一个传统的光学显微镜。它们使用吉姆萨染液将 150 个受恶性疟原虫感染的和 50 个健康病人的薄血涂片染色，这些薄血涂片是在孟加拉的吉大港医学院附属医院收集和照相的。使用智能手机的内置相机获取每个显微镜视窗内的图像。这些图片由在泰国曼谷的马希多-牛津热带医学研究所的一个专家使用幻灯片阅读器标记的。

让我们简要地查看一下数据集的结构。首先，我将安装一些基础的依赖（基于使用的操作系统）。

Installing dependencies

我使用的是云上的带有一个 GPU 的基于 Debian 的操作系统，这样我能更快的运行我的模型。为了查看目录结构，我们必须使用 sudo apt install tree 安装 tree 及其依赖（如果我们没有安装的话）。

Installing the tree dependency

我们有两个文件夹包含血细胞的图像，包括受感染的和健康的。我们通过输入可以获取关于图像总数更多的细节：

  1. import os
  2. import glob
  3.  
  4. base_dir = os.path.join('./cell_images')
  5. infected_dir = os.path.join(base_dir,'Parasitized')
  6. healthy_dir = os.path.join(base_dir,'Uninfected')
  7.  
  8. infected_files = glob.glob(infected_dir+'/*.png')
  9. healthy_files = glob.glob(healthy_dir+'/*.png')
  10. len(infected_files), len(healthy_files)
  11.  
  12. # Output
  13. (13779, 13779)

看起来我们有一个平衡的数据集，包含 13,779 张疟疾的和 13,779 张非疟疾的（健康的）血细胞图像。让我们根据这些构建数据帧，我们将用这些数据帧来构建我们的数据集。

  1. import numpy as np
  2. import pandas as pd
  3.  
  4. np.random.seed(42)
  5.  
  6. files_df = pd.DataFrame({
  7.     'filename': infected_files + healthy_files,
  8.     'label': ['malaria'] * len(infected_files) + ['healthy'] * len(healthy_files)
  9. }).sample(frac=1, random_state=42).reset_index(drop=True)
  10.  
  11. files_df.head()

Datasets

构建和了解图像数据集

为了构建深度学习模型，我们需要训练数据，但是我们还需要使用不可见的数据测试模型的性能。相应的，我们将使用 60:10:30 的比例来划分用于训练、验证和测试的数据集。我们将在训练期间应用训练和验证数据集，并用测试数据集来检查模型的性能。

  1. from sklearn.model_selection import train_test_split
  2. from collections import Counter
  3.  
  4. train_files, test_files, train_labels, test_labels = train_test_split(files_df['filename'].values,
  5.                                                                       files_df['label'].values, 
  6.                                                                       test_size=0.3, random_state=42)
  7. train_files, val_files, train_labels, val_labels = train_test_split(train_files,
  8.                                                                     train_labels, 
  9.                                                                     test_size=0.1, random_state=42)
  10.  
  11. print(train_files.shape, val_files.shape, test_files.shape)
  12. print('Train:', Counter(train_labels), '\nVal:', Counter(val_labels), '\nTest:', Counter(test_labels))
  13.  
  14. # Output
  15. (17361,) (1929,) (8268,)
  16. Train: Counter({'healthy': 8734, 'malaria': 8627}) 
  17. Val: Counter({'healthy': 970, 'malaria': 959}) 
  18. Test: Counter({'malaria': 4193, 'healthy': 4075})

这些图片尺寸并不相同，因为血涂片和细胞图像是基于人、测试方法、图片方向不同而不同的。让我们总结我们的训练数据集的统计信息来决定最佳的图像尺寸（牢记，我们根本不会碰测试数据集）。

  1. import cv2
  2. from concurrent import futures
  3. import threading
  4.  
  5. def get_img_shape_parallel(idx, img, total_imgs):
  6.     if idx % 5000 == 0 or idx == (total_imgs - 1):
  7.         print('{}: working on img num: {}'.format(threading.current_thread().name,
  8.                                                   idx))
  9.     return cv2.imread(img).shape
  10.   
  11. ex = futures.ThreadPoolExecutor(max_workers=None)
  12. data_inp = [(idx, img, len(train_files)) for idx, img in enumerate(train_files)]
  13. print('Starting Img shape computation:')
  14. train_img_dims_map = ex.map(get_img_shape_parallel, 
  15.                             [record[0] for record in data_inp],
  16.                             [record[1] for record in data_inp],
  17.                             [record[2] for record in data_inp])
  18. train_img_dims = list(train_img_dims_map)
  19. print('Min Dimensions:', np.min(train_img_dims, axis=0)) 
  20. print('Avg Dimensions:', np.mean(train_img_dims, axis=0))
  21. print('Median Dimensions:', np.median(train_img_dims, axis=0))
  22. print('Max Dimensions:', np.max(train_img_dims, axis=0))
  23.  
  24.  
  25. # Output
  26. Starting Img shape computation:
  27. ThreadPoolExecutor-0_0: working on img num: 0
  28. ThreadPoolExecutor-0_17: working on img num: 5000
  29. ThreadPoolExecutor-0_15: working on img num: 10000
  30. ThreadPoolExecutor-0_1: working on img num: 15000
  31. ThreadPoolExecutor-0_7: working on img num: 17360
  32. Min Dimensions: [46 46  3]
  33. Avg Dimensions: [132.77311215 132.45757733   3.]
  34. Median Dimensions: [130. 130.   3.]
  35. Max Dimensions: [385 394   3]

我们应用并行处理来加速图像读取，并且基于汇总统计结果，我们将每幅图片的尺寸重新调整到 125x125 像素。让我们载入我们所有的图像并重新调整它们为这些固定尺寸。

  1. IMG_DIMS = (125, 125)
  2.  
  3. def get_img_data_parallel(idx, img, total_imgs):
  4.     if idx % 5000 == 0 or idx == (total_imgs - 1):
  5.         print('{}: working on img num: {}'.format(threading.current_thread().name,
  6.                                                   idx))
  7.     img = cv2.imread(img)
  8.     img = cv2.resize(img, dsize=IMG_DIMS, 
  9.                      interpolation=cv2.INTER_CUBIC)
  10.     img = np.array(img, dtype=np.float32)
  11.     return img
  12.  
  13. ex = futures.ThreadPoolExecutor(max_workers=None)
  14. train_data_inp = [(idx, img, len(train_files)) for idx, img in enumerate(train_files)]
  15. val_data_inp = [(idx, img, len(val_files)) for idx, img in enumerate(val_files)]
  16. test_data_inp = [(idx, img, len(test_files)) for idx, img in enumerate(test_files)]
  17.  
  18. print('Loading Train Images:')
  19. train_data_map = ex.map(get_img_data_parallel, 
  20.                         [record[0] for record in train_data_inp],
  21.                         [record[1] for record in train_data_inp],
  22.                         [record[2] for record in train_data_inp])
  23. train_data = np.array(list(train_data_map))
  24.  
  25. print('\nLoading Validation Images:')
  26. val_data_map = ex.map(get_img_data_parallel, 
  27.                         [record[0] for record in val_data_inp],
  28.                         [record[1] for record in val_data_inp],
  29.                         [record[2] for record in val_data_inp])
  30. val_data = np.array(list(val_data_map))
  31.  
  32. print('\nLoading Test Images:')
  33. test_data_map = ex.map(get_img_data_parallel, 
  34.                         [record[0] for record in test_data_inp],
  35.                         [record[1] for record in test_data_inp],
  36.                         [record[2] for record in test_data_inp])
  37. test_data = np.array(list(test_data_map))
  38.  
  39. train_data.shape, val_data.shape, test_data.shape  
  40.  
  41.  
  42. # Output
  43. Loading Train Images:
  44. ThreadPoolExecutor-1_0: working on img num: 0
  45. ThreadPoolExecutor-1_12: working on img num: 5000
  46. ThreadPoolExecutor-1_6: working on img num: 10000
  47. ThreadPoolExecutor-1_10: working on img num: 15000
  48. ThreadPoolExecutor-1_3: working on img num: 17360
  49.  
  50. Loading Validation Images:
  51. ThreadPoolExecutor-1_13: working on img num: 0
  52. ThreadPoolExecutor-1_18: working on img num: 1928
  53.  
  54. Loading Test Images:
  55. ThreadPoolExecutor-1_5: working on img num: 0
  56. ThreadPoolExecutor-1_19: working on img num: 5000
  57. ThreadPoolExecutor-1_8: working on img num: 8267
  58. ((17361, 125, 125, 3), (1929, 125, 125, 3), (8268, 125, 125, 3))

我们再次应用并行处理来加速有关图像载入和重新调整大小的计算。最终，我们获得了所需尺寸的图片张量，正如前面的输出所示。我们现在查看一些血细胞图像样本，以对我们的数据有个印象。

  1. import matplotlib.pyplot as plt
  2. %matplotlib inline
  3.  
  4. plt.figure(1 , figsize = (8 , 8))
  5. n = 0 
  6. for i in range(16):
  7.     n += 1 
  8.     r = np.random.randint(0 , train_data.shape[0] , 1)
  9.     plt.subplot(4 , 4 , n)
  10.     plt.subplots_adjust(hspace = 0.5 , wspace = 0.5)
  11.     plt.imshow(train_data[r[0]]/255.)
  12.     plt.title('{}'.format(train_labels[r[0]]))
  13.     plt.xticks([]) , plt.yticks([])

Malaria cell samples

基于这些样本图像，我们看到一些疟疾和健康细胞图像的细微不同。我们将使我们的深度学习模型试图在模型训练中学习这些模式。

开始我们的模型训练前，我们必须建立一些基础的配置设置。

  1. BATCH_SIZE = 64
  2. NUM_CLASSES = 2
  3. EPOCHS = 25
  4. INPUT_SHAPE = (125, 125, 3)
  5.  
  6. train_imgs_scaled = train_data / 255.
  7. val_imgs_scaled = val_data / 255.
  8.  
  9. # encode text category labels
  10. from sklearn.preprocessing import LabelEncoder
  11.  
  12. le = LabelEncoder()
  13. le.fit(train_labels)
  14. train_labels_enc = le.transform(train_labels)
  15. val_labels_enc = le.transform(val_labels)
  16.  
  17. print(train_labels[:6], train_labels_enc[:6])
  18.  
  19.  
  20. # Output
  21. ['malaria' 'malaria' 'malaria' 'healthy' 'healthy' 'malaria'] [1 1 1 0 0 1]

我们修复我们的图像尺寸、批量大小，和纪元，并编码我们的分类的类标签。TensorFlow 2.0 于 2019 年三月发布，这个练习是尝试它的完美理由。

  1. import tensorflow as tf
  2.  
  3. # Load the TensorBoard notebook extension (optional)
  4. %load_ext tensorboard.notebook
  5.  
  6. tf.random.set_seed(42)
  7. tf.__version__
  8.  
  9. # Output
  10. '2.0.0-alpha0'

深度学习训练

在模型训练阶段，我们将构建三个深度训练模型，使用我们的训练集训练，使用验证数据比较它们的性能。然后，我们保存这些模型并在之后的模型评估阶段使用它们。

模型 1：从头开始的 CNN

我们的第一个疟疾检测模型将从头开始构建和训练一个基础的 CNN。首先，让我们定义我们的模型架构，

  1. inp = tf.keras.layers.Input(shape=INPUT_SHAPE)
  2.  
  3. conv1 = tf.keras.layers.Conv2D(32, kernel_size=(3, 3), 
  4.                                activation='relu', padding='same')(inp)
  5. pool1 = tf.keras.layers.MaxPooling2D(pool_size=(2, 2))(conv1)
  6. conv2 = tf.keras.layers.Conv2D(64, kernel_size=(3, 3), 
  7.                                activation='relu', padding='same')(pool1)
  8. pool2 = tf.keras.layers.MaxPooling2D(pool_size=(2, 2))(conv2)
  9. conv3 = tf.keras.layers.Conv2D(128, kernel_size=(3, 3), 
  10.                                activation='relu', padding='same')(pool2)
  11. pool3 = tf.keras.layers.MaxPooling2D(pool_size=(2, 2))(conv3)
  12.  
  13. flat = tf.keras.layers.Flatten()(pool3)
  14.  
  15. hidden1 = tf.keras.layers.Dense(512, activation='relu')(flat)
  16. drop1 = tf.keras.layers.Dropout(rate=0.3)(hidden1)
  17. hidden2 = tf.keras.layers.Dense(512, activation='relu')(drop1)
  18. drop2 = tf.keras.layers.Dropout(rate=0.3)(hidden2)
  19.  
  20. out = tf.keras.layers.Dense(1, activation='sigmoid')(drop2)
  21.  
  22. model = tf.keras.Model(inputs=inp, outputs=out)
  23. model.compile(optimizer='adam',
  24.                 loss='binary_crossentropy',
  25.                 metrics=['accuracy'])
  26. model.summary()
  27.  
  28.  
  29. # Output
  30. Model: "model"
  31. _________________________________________________________________
  32. Layer (type)                 Output Shape              Param #   
  33. =================================================================
  34. input_1 (InputLayer)         [(None, 125, 125, 3)]     0         
  35. _________________________________________________________________
  36. conv2d (Conv2D)              (None, 125, 125, 32)      896       
  37. _________________________________________________________________
  38. max_pooling2d (MaxPooling2D) (None, 62, 62, 32)        0         
  39. _________________________________________________________________
  40. conv2d_1 (Conv2D)            (None, 62, 62, 64)        18496     
  41. _________________________________________________________________
  42. ...
  43. ...
  44. _________________________________________________________________
  45. dense_1 (Dense)              (None, 512)               262656    
  46. _________________________________________________________________
  47. dropout_1 (Dropout)          (None, 512)               0         
  48. _________________________________________________________________
  49. dense_2 (Dense)              (None, 1)                 513       
  50. =================================================================
  51. Total params: 15,102,529
  52. Trainable params: 15,102,529
  53. Non-trainable params: 0
  54. _________________________________________________________________

基于这些代码的架构，我们的 CNN 模型有三个卷积和一个池化层，其后是两个致密层，以及用于正则化的失活。让我们训练我们的模型。

  1. import datetime
  2.  
  3. logdir = os.path.join('/home/dipanzan_sarkar/projects/tensorboard_logs', 
  4.                       datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
  5. tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir, histogram_freq=1)
  6. reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.5,
  7.                               patience=2, min_lr=0.000001)
  8. callbacks = [reduce_lr, tensorboard_callback]
  9.  
  10. history = model.fit(x=train_imgs_scaled, y=train_labels_enc, 
  11.                     batch_size=BATCH_SIZE,
  12.                     epochs=EPOCHS, 
  13.                     validation_data=(val_imgs_scaled, val_labels_enc), 
  14.                     callbacks=callbacks,
  15.                     verbose=1)
  16.                     
  17.  
  18. # Output
  19. Train on 17361 samples, validate on 1929 samples
  20. Epoch 1/25
  21. 17361/17361 [====] - 32s 2ms/sample - loss: 0.4373 - accuracy: 0.7814 - val_loss: 0.1834 - val_accuracy: 0.9393
  22. Epoch 2/25
  23. 17361/17361 [====] - 30s 2ms/sample - loss: 0.1725 - accuracy: 0.9434 - val_loss: 0.1567 - val_accuracy: 0.9513
  24. ...
  25. ...
  26. Epoch 24/25
  27. 17361/17361 [====] - 30s 2ms/sample - loss: 0.0036 - accuracy: 0.9993 - val_loss: 0.3693 - val_accuracy: 0.9565
  28. Epoch 25/25
  29. 17361/17361 [====] - 30s 2ms/sample - loss: 0.0034 - accuracy: 0.9994 - val_loss: 0.3699 - val_accuracy: 0.9559

我们获得了 95.6% 的验证精确率，这很好，尽管我们的模型看起来有些过拟合（通过查看我们的训练精确度，是 99.9%）。通过绘制训练和验证的精度和损失曲线，我们可以清楚地看到这一点。

  1. f, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
  2. t = f.suptitle('Basic CNN Performance', fontsize=12)
  3. f.subplots_adjust(top=0.85, wspace=0.3)
  4.  
  5. max_epoch = len(history.history['accuracy'])+1
  6. epoch_list = list(range(1,max_epoch))
  7. ax1.plot(epoch_list, history.history['accuracy'], label='Train Accuracy')
  8. ax1.plot(epoch_list, history.history['val_accuracy'], label='Validation Accuracy')
  9. ax1.set_xticks(np.arange(1, max_epoch, 5))
  10. ax1.set_ylabel('Accuracy Value')
  11. ax1.set_xlabel('Epoch')
  12. ax1.set_title('Accuracy')
  13. l1 = ax1.legend(loc="best")
  14.  
  15. ax2.plot(epoch_list, history.history['loss'], label='Train Loss')
  16. ax2.plot(epoch_list, history.history['val_loss'], label='Validation Loss')
  17. ax2.set_xticks(np.arange(1, max_epoch, 5))
  18. ax2.set_ylabel('Loss Value')
  19. ax2.set_xlabel('Epoch')
  20. ax2.set_title('Loss')
  21. l2 = ax2.legend(loc="best")

基础 CNN 学习曲线

我们可以看在在第五个纪元，情况并没有改善很多。让我们保存这个模型用于将来的评估。

  1. model.save('basic_cnn.h5')

深度迁移学习

就像人类有与生俱来在不同任务间传输知识的能力一样，迁移学习允许我们利用从以前任务学到的知识用到新的相关的任务，即使在机器学习或深度学习的情况下也是如此。如果想深入探究迁移学习，你应该看我的文章“一个易于理解与现实应用一起学习深度学习中的迁移学习的指导实践”和我的书《Python 迁移学习实践》。

深度迁移学习的想法

在这篇实践中我们想要探索的想法是：

在我们的问题背景下，我们能够利用一个预训练深度学习模型（在大数据集上训练的，像 ImageNet）通过应用和迁移知识来解决疟疾检测的问题吗？

我们将应用两个最流行的深度迁移学习策略。

  • 预训练模型作为特征提取器
  • 微调的预训练模型

我们将使用预训练的 VGG-19 深度训练模型（由剑桥大学的视觉几何组（VGG）开发）进行我们的实验。像 VGG-19 这样的预训练模型是在一个大的数据集（Imagenet）上使用了很多不同的图像分类训练的。因此，这个模型应该已经学习到了健壮的特征层级结构，相对于你的 CNN 模型学到的特征，是空间不变的、转动不变的、平移不变的。因此，这个模型，已经从百万幅图片中学习到了一个好的特征显示，对于像疟疾检测这样的计算机视觉问题，可以作为一个好的合适新图像的特征提取器。在我们的问题中发挥迁移学习的能力之前，让我们先讨论 VGG-19 模型。

理解 VGG-19 模型

VGG-19 模型是一个构建在 ImageNet 数据库之上的 19 层（卷积和全连接的）的深度学习网络，ImageNet 数据库为了图像识别和分类的目的而开发。该模型是由 Karen Simonyan 和 Andrew Zisserman 构建的，在他们的论文“大规模图像识别的非常深的卷积网络”中进行了描述。VGG-19 的架构模型是：

VGG-19 模型架构

你可以看到我们总共有 16 个使用 3x3 卷积过滤器的卷积层，与最大的池化层来下采样，和由 4096 个单元组成的两个全连接的隐藏层，每个隐藏层之后跟随一个由 1000 个单元组成的致密层，每个单元代表 ImageNet 数据库中的一个分类。我们不需要最后三层，因为我们将使用我们自己的全连接致密层来预测疟疾。我们更关心前五个块，因此我们可以利用 VGG 模型作为一个有效的特征提取器。

我们将使用模型之一作为一个简单的特征提取器，通过冻结五个卷积块的方式来确保它们的位权在每个纪元后不会更新。对于最后一个模型，我们会对 VGG 模型进行微调，我们会解冻最后两个块（第 4 和第 5）因此当我们训练我们的模型时，它们的位权在每个时期（每批数据）被更新。

模型 2：预训练的模型作为一个特征提取器

为了构建这个模型，我们将利用 TensorFlow 载入 VGG-19 模型并冻结卷积块，因此我们能够将它们用作特征提取器。我们在末尾插入我们自己的致密层来执行分类任务。

  1. vgg = tf.keras.applications.vgg19.VGG19(include_top=False, weights='imagenet', 
  2.                                         input_shape=INPUT_SHAPE)
  3. vgg.trainable = False
  4. # Freeze the layers
  5. for layer in vgg.layers:
  6.     layer.trainable = False
  7.     
  8. base_vgg = vgg
  9. base_out = base_vgg.output
  10. pool_out = tf.keras.layers.Flatten()(base_out)
  11. hidden1 = tf.keras.layers.Dense(512, activation='relu')(pool_out)
  12. drop1 = tf.keras.layers.Dropout(rate=0.3)(hidden1)
  13. hidden2 = tf.keras.layers.Dense(512, activation='relu')(drop1)
  14. drop2 = tf.keras.layers.Dropout(rate=0.3)(hidden2)
  15.  
  16. out = tf.keras.layers.Dense(1, activation='sigmoid')(drop2)
  17.  
  18. model = tf.keras.Model(inputs=base_vgg.input, outputs=out)
  19. model.compile(optimizer=tf.keras.optimizers.RMSprop(lr=1e-4),
  20.                 loss='binary_crossentropy',
  21.                 metrics=['accuracy'])
  22. model.summary()
  23.  
  24.  
  25. # Output
  26. Model: "model_1"
  27. _________________________________________________________________
  28. Layer (type)                 Output Shape              Param #   
  29. =================================================================
  30. input_2 (InputLayer)         [(None, 125, 125, 3)]     0         
  31. _________________________________________________________________
  32. block1_conv1 (Conv2D)        (None, 125, 125, 64)      1792      
  33. _________________________________________________________________
  34. block1_conv2 (Conv2D)        (None, 125, 125, 64)      36928     
  35. _________________________________________________________________
  36. ...
  37. ...
  38. _________________________________________________________________
  39. block5_pool (MaxPooling2D)   (None, 3, 3, 512)         0         
  40. _________________________________________________________________
  41. flatten_1 (Flatten)          (None, 4608)              0         
  42. _________________________________________________________________
  43. dense_3 (Dense)              (None, 512)               2359808   
  44. _________________________________________________________________
  45. dropout_2 (Dropout)          (None, 512)               0         
  46. _________________________________________________________________
  47. dense_4 (Dense)              (None, 512)               262656    
  48. _________________________________________________________________
  49. dropout_3 (Dropout)          (None, 512)               0         
  50. _________________________________________________________________
  51. dense_5 (Dense)              (None, 1)                 513       
  52. =================================================================
  53. Total params: 22,647,361
  54. Trainable params: 2,622,977
  55. Non-trainable params: 20,024,384
  56. _________________________________________________________________

从整个输出可以明显看出，在我们的模型中我们有了很多层，我们将只利用 VGG-19 模型的冻结层作为特征提取器。你可以使用下列代码来验证我们的模型有多少层是实际可训练的，以及我们的网络中总共存在多少层。

  1. print("Total Layers:", len(model.layers))
  2. print("Total trainable layers:", 
  3.       sum([1 for l in model.layers if l.trainable]))
  4.  
  5. # Output
  6. Total Layers: 28
  7. Total trainable layers: 6

我们将使用和我们之前的模型相似的配置和回调来训练我们的模型。参考我的 GitHub 仓库以获取训练模型的完整代码。我们观察下列图表，以显示模型精确度和损失曲线。

冻结的预训练的 CNN 的学习曲线

这表明我们的模型没有像我们的基础 CNN 模型那样过拟合，但是性能有点不如我们的基础的 CNN 模型。让我们保存这个模型，以备将来的评估。

  1. model.save('vgg_frozen.h5')

模型 3：使用图像增强来微调预训练的模型

在我们的最后一个模型中，我们将在预定义好的 VGG-19 模型的最后两个块中微调层的位权。我们同样引入了图像增强的概念。图像增强背后的想法和其名字一样。我们从训练数据集中载入现有图像，并且应用转换操作，例如旋转、裁剪、转换、放大缩小等等，来产生新的、改变过的版本。由于这些随机转换，我们每次获取到的图像不一样。我们将应用 tf.keras 中的一个名为 ImageDataGenerator 的优秀工具来帮助构建图像增强器。

  1. train_datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255,
  2.                                                                 zoom_range=0.05, 
  3.                                                                 rotation_range=25,
  4.                                                                 width_shift_range=0.05, 
  5.                                                                 height_shift_range=0.05, 
  6.                                                                 shear_range=0.05, horizontal_flip=True, 
  7.                                                                 fill_mode='nearest')
  8.  
  9. val_datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255)
  10.  
  11. # build image augmentation generators
  12. train_generator = train_datagen.flow(train_data, train_labels_enc, batch_size=BATCH_SIZE, shuffle=True)
  13. val_generator = val_datagen.flow(val_data, val_labels_enc, batch_size=BATCH_SIZE, shuffle=False)

我们不会对我们的验证数据集应用任何转换（除非是调整大小，因为这是必须的），因为我们将使用它评估每个纪元的模型性能。对于在传输学习环境中的图像增强的详细解释，请随时查看我上面引用的文章。让我们从一批图像增强转换中查看一些样本结果。

  1. img_id = 0
  2. sample_generator = train_datagen.flow(train_data[img_id:img_id+1], train_labels[img_id:img_id+1],
  3.                                       batch_size=1)
  4. sample = [next(sample_generator) for i in range(0,5)]
  5. fig, ax = plt.subplots(1,5, figsize=(16, 6))
  6. print('Labels:', [item[1][0] for item in sample])
  7. l = [ax[i].imshow(sample[i][0][0]) for i in range(0,5)]

Sample augmented images

你可以清晰的看到与之前的输出的我们图像的轻微变化。我们现在构建我们的学习模型，确保 VGG-19 模型的最后两块是可以训练的。

  1. vgg = tf.keras.applications.vgg19.VGG19(include_top=False, weights='imagenet', 
  2.                                         input_shape=INPUT_SHAPE)
  3. # Freeze the layers
  4. vgg.trainable = True
  5.  
  6. set_trainable = False
  7. for layer in vgg.layers:
  8.     if layer.name in ['block5_conv1', 'block4_conv1']:
  9.         set_trainable = True
  10.     if set_trainable:
  11.         layer.trainable = True
  12.     else:
  13.         layer.trainable = False
  14.     
  15. base_vgg = vgg
  16. base_out = base_vgg.output
  17. pool_out = tf.keras.layers.Flatten()(base_out)
  18. hidden1 = tf.keras.layers.Dense(512, activation='relu')(pool_out)
  19. drop1 = tf.keras.layers.Dropout(rate=0.3)(hidden1)
  20. hidden2 = tf.keras.layers.Dense(512, activation='relu')(drop1)
  21. drop2 = tf.keras.layers.Dropout(rate=0.3)(hidden2)
  22.  
  23. out = tf.keras.layers.Dense(1, activation='sigmoid')(drop2)
  24.  
  25. model = tf.keras.Model(inputs=base_vgg.input, outputs=out)
  26. model.compile(optimizer=tf.keras.optimizers.RMSprop(lr=1e-5),
  27.                 loss='binary_crossentropy',
  28.                 metrics=['accuracy'])
  29.  
  30. print("Total Layers:", len(model.layers))
  31. print("Total trainable layers:", sum([1 for l in model.layers if l.trainable]))
  32.  
  33.  
  34. # Output
  35. Total Layers: 28
  36. Total trainable layers: 16

在我们的模型中我们降低了学习率，因为我们不想在微调的时候对预训练的层做大的位权更新。模型的训练过程可能有轻微的不同，因为我们使用了数据生成器，因此我们将应用 fit_generator(...) 函数。

  1. tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir, histogram_freq=1)
  2. reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.5,
  3.                               patience=2, min_lr=0.000001)
  4.  
  5. callbacks = [reduce_lr, tensorboard_callback]
  6. train_steps_per_epoch = train_generator.n // train_generator.batch_size
  7. val_steps_per_epoch = val_generator.n // val_generator.batch_size
  8. history = model.fit_generator(train_generator, steps_per_epoch=train_steps_per_epoch, epochs=EPOCHS,
  9.                               validation_data=val_generator, validation_steps=val_steps_per_epoch, 
  10.                               verbose=1)
  11.  
  12.  
  13. # Output
  14. Epoch 1/25
  15. 271/271 [====] - 133s 489ms/step - loss: 0.2267 - accuracy: 0.9117 - val_loss: 0.1414 - val_accuracy: 0.9531
  16. Epoch 2/25
  17. 271/271 [====] - 129s 475ms/step - loss: 0.1399 - accuracy: 0.9552 - val_loss: 0.1292 - val_accuracy: 0.9589
  18. ...
  19. ...
  20. Epoch 24/25
  21. 271/271 [====] - 128s 473ms/step - loss: 0.0815 - accuracy: 0.9727 - val_loss: 0.1466 - val_accuracy: 0.9682
  22. Epoch 25/25
  23. 271/271 [====] - 128s 473ms/step - loss: 0.0792 - accuracy: 0.9729 - val_loss: 0.1127 - val_accuracy: 0.9641

这看起来是我们的最好的模型。它给了我们近乎 96.5% 的验证精确率，基于训练精度，它看起来不像我们的第一个模型那样过拟合。这可以通过下列的学习曲线验证。

微调过的预训练 CNN 的学习曲线

让我们保存这个模型，因此我们能够在测试集上使用。

  1. model.save('vgg_finetuned.h5')

这就完成了我们的模型训练阶段。现在我们准备好了在测试集上测试我们模型的性能。

深度学习模型性能评估

我们将通过在我们的测试集上做预测来评估我们在训练阶段构建的三个模型，因为仅仅验证是不够的！我们同样构建了一个检测工具模块叫做 model_evaluation_utils，我们可以使用相关分类指标用来评估使用我们深度学习模型的性能。第一步是扩展我们的数据集。

  1. test_imgs_scaled = test_data / 255.
  2. test_imgs_scaled.shape, test_labels.shape
  3.  
  4. # Output
  5. ((8268, 125, 125, 3), (8268,))

下一步包括载入我们保存的深度学习模型，在测试集上预测。

  1. # Load Saved Deep Learning Models
  2. basic_cnn = tf.keras.models.load_model('./basic_cnn.h5')
  3. vgg_frz = tf.keras.models.load_model('./vgg_frozen.h5')
  4. vgg_ft = tf.keras.models.load_model('./vgg_finetuned.h5')
  5.  
  6. # Make Predictions on Test Data
  7. basic_cnn_preds = basic_cnn.predict(test_imgs_scaled, batch_size=512)
  8. vgg_frz_preds = vgg_frz.predict(test_imgs_scaled, batch_size=512)
  9. vgg_ft_preds = vgg_ft.predict(test_imgs_scaled, batch_size=512)
  10.  
  11. basic_cnn_pred_labels = le.inverse_transform([1 if pred > 0.5 else 0 
  12.                                                   for pred in basic_cnn_preds.ravel()])
  13. vgg_frz_pred_labels = le.inverse_transform([1 if pred > 0.5 else 0 
  14.                                                   for pred in vgg_frz_preds.ravel()])
  15. vgg_ft_pred_labels = le.inverse_transform([1 if pred > 0.5 else 0 
  16.                                                   for pred in vgg_ft_preds.ravel()])

下一步是应用我们的 model_evaluation_utils 模块根据相应分类指标来检查每个模块的性能。

  1. import model_evaluation_utils as meu
  2. import pandas as pd
  3.  
  4. basic_cnn_metrics = meu.get_metrics(true_labels=test_labels, predicted_labels=basic_cnn_pred_labels)
  5. vgg_frz_metrics = meu.get_metrics(true_labels=test_labels, predicted_labels=vgg_frz_pred_labels)
  6. vgg_ft_metrics = meu.get_metrics(true_labels=test_labels, predicted_labels=vgg_ft_pred_labels)
  7.  
  8. pd.DataFrame([basic_cnn_metrics, vgg_frz_metrics, vgg_ft_metrics], 
  9.              index=['Basic CNN', 'VGG-19 Frozen', 'VGG-19 Fine-tuned'])

Model accuracy

看起来我们的第三个模型在我们的测试集上执行的最好，给出了一个模型精确性为 96% 的 F1 得分，这非常好，与我们之前提到的研究论文和文章中的更复杂的模型相当。

总结

疟疾检测不是一个简单的过程，全球的合格人员的不足在病例诊断和治疗当中是一个严重的问题。我们研究了一个关于疟疾的有趣的真实世界的医学影像案例。利用 AI 的、易于构建的、开源的技术在检测疟疾方面可以为我们提供最先进的精确性，因此使 AI 具有社会效益。

我鼓励你查看这篇文章中提到的文章和研究论文，没有它们，我就不能形成概念并写出来。如果你对运行和采纳这些技术感兴趣，本篇文章所有的代码都可以在我的 GitHub 仓库获得。记得从官方网站下载数据。

让我们希望在健康医疗方面更多的采纳开源的 AI 能力，使它在世界范围内变得更便宜、更易用。

相关内容