• 深度学习实战（2）：肺炎预测｜附数据集与源码

    目录

    写在前面

    项目任务简介

    实验结果

    导入需要的第三方库 

    定义预处理函数 

    加载数据集路径 

    加载训练集的图像和标签 

    部分图片展示 

    加载测试图片

    Pickle存储已处理好的图片

    标签预处理 

    将X转化为（None, 200,200,1）的格式

    数据增强 

    构建CNN神经网络 

    展示CNN模型的详细信息 

    Model.complie

    训练过程展示 

    结果展示

    结果分析 

    模型评估 

     

    写在前面

    * 本篇文章仅作为深度学习学习用途 而非商用

    * 运行系统 ：MacOS / Windows

    * Python版本 ：Python3.0

    * 运行平台：Visual Studio Code

    🤯

    6d2ca9d86e284106a171781eb3ec2ec0.jpeg

     

    项目任务简介

    在已有的数据集下，训练一个CNN模型，预测一张CT图的肺部照片是否患有肺炎，若是患有肺炎，是因为细菌还是病毒引起的。数据集共有三个子文件夹：train / test / val 他们的作用相信各位都已经很清楚了 字面意思 这里不再多加赘述。

    实验结果

    接近80%的Accuracy，验证集和训练集的拟合程度较好（并未达到最好，赠机epoch或者更换学习函数可能可以更好的训练模型，这里只迭代30次（呜呜CPU的痛 各位如果有GPU可以适当增肌迭代次数） 

    导入需要的第三方库 

    在执行深度学习项目时，要做的第一件事就是加载所有必需的模块和图像数据本身。

    在这里qdm模块的作用是来显示进度条。

    1. import os
    2. import cv2
    3. import pickle
    4. import numpy as np
    5. import matplotlib.pyplot as plt
    6. import seaborn as sns
    7. from tqdm import tqdm
    8. from sklearn.preprocessing import OneHotEncoder
    9. from sklearn.metrics import confusion_matrix
    10. from keras.models import Model, load_model
    11. from keras.layers import Dense, Input, Conv2D, MaxPool2D, Flatten
    12. from keras.preprocessing.image import ImageDataGenerator
    13. np.random.seed(22)

    定义预处理函数 

    以下两个函数来从每个文件夹加载图像数据。

     

    首先，所有图像的大小都将调整为200 x 200像素。这很重要，因为所有文件夹中的图像都具有不同的维度，而神经网络只能接受具有固定阵列大小的数据。接下来，默认情况所有图像都存储在3个彩色通道中，但本次试验我们所用的数据集的图片均为灰度图，因此，这里需要将所有这些彩色图像转换为灰度。（  很重要的点！）

     

    其中的这句话：

    if image == '.DS_Store' : continue

    如果您是Mac电脑，需要加上，Windows电脑的删去即可，当然不删也不会有任何的影响。

    1. def load_normal(norm_path):
    2.     norm_files = np.array(os.listdir(norm_path))
    3.     norm_labels = np.array(['normal']*len(norm_files))
    4.     
    5.     norm_images = []
    6.     for image in tqdm(norm_files):
    7. 		# Read image
    8.         if image == '.DS_Store' : continue
    9.         image = cv2.imread(norm_path + image)
    10. 		# Resize image to 200x200 px
    11.         image = cv2.resize(image, dsize=(200,200))
    12. 		# Convert to grayscale
    13.         image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    14.         norm_images.append(image)
    15.         
    16.     norm_images = np.array(norm_images)
    17.     
    18.     return norm_images, norm_labels
    19.  
    20. def load_pneumonia(pneu_path):
    21.     pneu_files = np.array(os.listdir(pneu_path))
    22.     pneu_labels = np.array([pneu_file.split('_')[1] for pneu_file in pneu_files])
    23.     
    24.     pneu_images = []
    25.     for image in tqdm(pneu_files):
    26. 		# Read image
    27.         if image == '.DS_Store' : continue
    28.         image = cv2.imread(pneu_path + image)
    29. 		# Resize image to 200x200 px
    30.         image = cv2.resize(image, dsize=(200,200))
    31. 		# Convert to grayscale
    32.         image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    33.         pneu_images.append(image)
    34.         
    35.     pneu_images = np.array(pneu_images)
    36.     
    37.     return pneu_images, pneu_labels

    加载数据集路径 

    1. norm_images, norm_labels = load_normal('/Users/liqun/Desktop/KS/MyPython/DataSet/chest_xray/train/NORMAL/')
    2. pneu_images, pneu_labels = load_pneumonia('/Users/liqun/Desktop/KS/MyPython/DataSet/chest_xray/train/PNEUMONIA/')

    加载训练集的图像和标签 

    1. X_train = np.append(norm_images, pneu_images, axis=0)
    2. y_train = np.append(norm_labels, pneu_labels)

    94342498736e40508ad964eb9ad2c6e0.png 

    在Jupyter Notebook中可以输入这两个语句查看是否成功导入了数据

     65245f20ef4344c99b7ba71c305e7512.png

    同理，可以查看每一个类别分别有多少张图片

    部分图片展示 

    这个展示并不是必须的，只是这里可以用于检查图片的颜色通道、尺寸等是否已经转化为期待的样子了。

    1. fig, axes = plt.subplots(ncols=7, nrows=2, figsize=(16, 4))
    2.  
    3. indices = np.random.choice(len(X_train), 14)
    4. counter = 0
    5.  
    6. for i in range(2):
    7.     for j in range(7):
    8.         axes[i,j].set_title(y_train[indices[counter]])
    9.         axes[i,j].imshow(X_train[indices[counter]], cmap='gray')
    10.         axes[i,j].get_xaxis().set_visible(False)
    11.         axes[i,j].get_yaxis().set_visible(False)
    12.         counter += 1
    13. plt.show()

    加载测试图片

    和上方加载训练集的图片过程类似，函数也是相同的，测试集共有624张图片

    1. print('Loading test images')
    2. # Do the exact same thing as what we have done on train data
    3. norm_images_test, norm_labels_test = load_normal('/Users/liqun/Desktop/KS/MyPython/DataSet/chest_xray/test/NORMAL/')
    4. pneu_images_test, pneu_labels_test = load_pneumonia('/Users/liqun/Desktop/KS/MyPython/DataSet/chest_xray/test/PNEUMONIA/')
    5. X_test = np.append(norm_images_test, pneu_images_test, axis=0)
    6. y_test = np.append(norm_labels_test, pneu_labels_test)

    Pickle存储已处理好的图片

    由于这里处理图片格式就花费大量的时间，所以可以使用pickle库，它可以存储这些转化好的图片，下次再使用的时候就不需要重新重复上面的操作了

    1. with open('pneumonia_data.pickle', 'wb') as f:
    2.     pickle.dump((X_train, X_test, y_train, y_test), f)
    3.  
    4. with open('pneumonia_data.pickle', 'rb') as f:
    5.     (X_train, X_test, y_train, y_test) = pickle.load(f)

    标签预处理 

    此时，两个Y变量都由以字符串数据类型编写的正常变量、细菌或病毒组成。但是，神经网络无法接受这样的标签。因此，我们需要将其转换为单热格式。

    1. y_train = y_train[:, np.newaxis]
    2. y_test = y_test[:, np.newaxis]
    3. one_hot_encoder = OneHotEncoder(sparse=False)
    4. y_train_one_hot = one_hot_encoder.fit_transform(y_train)
    5. y_test_one_hot = one_hot_encoder.transform(y_test)

    将X转化为（None, 200,200,1）的格式

    1. X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], X_train.shape[2], 1)
    2. X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], X_test.shape[2], 1)

    数据增强 

    增加数据指的是，我们将通过在每个样本上创建更多具有某种随机性的样本来增加用于训练的数据数量。这些随机性可能包括翻译、旋转、缩放、剪切和翻转。这种技术能够帮助我们的神经网络分类器减少过度拟合。

    1. datagen = ImageDataGenerator(
    2.         rotation_range = 10,  
    3.         zoom_range = 0.1, 
    4.         width_shift_range = 0.1, 
    5.         height_shift_range = 0.1)
    6.  
    7. datagen.fit(X_train)
    8. train_gen = datagen.flow(X_train, y_train_one_hot, batch_size=32)

    如有需要，可以了解一下ImageDataGenerator函数的参数构成：

    ImageDataGenerator详解

    构建CNN神经网络 

    我们需要确保第一层接受与图像大小完全相同的形状。值得注意的是，我们需要定义的只是（宽度、高度、通道），而不是（样本、宽度、高度、通道）。

     

    之后，该输入层连接到几个卷积池层，最终被扁平并连接到Dense层。模型中的所有隐藏层都在使用Relu激活函数，RelU的计算速度快，因此所需的训练时间短。最后，连接的最后一层是输出，它由3个具有softmax激活功能的神经元组成。这里使用softmax是因为我们希望输出是每个类的概率值。 

    1. input1 = Input(shape=(X_train.shape[1], X_train.shape[2], 1))
    2.  
    3. cnn = Conv2D(16, (3, 3), activation='relu', strides=(1, 1), 
    4.     padding='same')(input1)
    5. cnn = Conv2D(32, (3, 3), activation='relu', strides=(1, 1), 
    6.     padding='same')(cnn)
    7. cnn = MaxPool2D((2, 2))(cnn)
    8.  
    9. cnn = Conv2D(16, (2, 2), activation='relu', strides=(1, 1), 
    10.     padding='same')(cnn)
    11. cnn = Conv2D(32, (2, 2), activation='relu', strides=(1, 1), 
    12.     padding='same')(cnn)
    13. cnn = MaxPool2D((2, 2))(cnn)
    14.  
    15. cnn = Flatten()(cnn)
    16. cnn = Dense(100, activation='relu')(cnn)
    17. cnn = Dense(50, activation='relu')(cnn)
    18. output1 = Dense(3, activation='softmax')(cnn)
    19.  
    20. model = Model(inputs=input1, outputs=output1)

    展示CNN模型的详细信息 

    7644105fd7164ed4a2c99cb4725a7458.png 

    Model.complie

    在构建模型后，现在我们使用categorical_crossentropy损失函数和Adam优化器编译神经网络。使用这个点损失函数的原因是，它是多类分类任务中常用的函数。而Adam作为优化器，是大多数神经网络任务中最小化损失值的最佳优化器。 

    1. model.compile(loss='categorical_crossentropy', 
    2.               optimizer='adam', metrics=['acc'])

    训练过程展示 

    e907d9b5a9b04d1a9a9540a65f65e735.png

    一共迭代了30次，这里仅展示了最后四次的迭代结果 

    结果展示

    1. plt.figure(figsize=(8,6))
    2. plt.title('Accuracy scores')
    3. plt.plot(history.history['acc'])
    4. plt.plot(history.history['val_acc'])
    5. plt.legend(['acc', 'val_acc'])
    6. plt.show()
    7. plt.figure(figsize=(8,6))
    8. plt.title('Loss value')
    9. plt.plot(history.history['loss'])
    10. plt.plot(history.history['val_loss'])
    11. plt.legend(['loss', 'val_loss'])
    12. plt.show()

    9c1b91c2246843c7a8f06e969094c1da.png 

    e8b51c7c481e4fe4859e48c613313b59.png 

    结果分析 

    由于我们前面将数据增强了，所以我们发现模型训练结果没有出现过拟合的状况，尽管accuracy的波动仍然存在，但整体的趋势是较为正常且能接受的。

    模型评估 

    1. predictions = model.predict(X_test)
    2. predictions = one_hot_encoder.inverse_transform(predictions)
    3. cm = confusion_matrix(y_test, predictions)
    4.  
    5. classnames = ['bacteria', 'normal', 'virus']
    6. plt.figure(figsize=(8,8))
    7. plt.title('Confusion matrix')
    8. sns.heatmap(cm, cbar=False, xticklabels=classnames, yticklabels=classnames, fmt='d', annot=True, cmap=plt.cm.Blues)
    9. plt.xlabel('Predicted')
    10. plt.ylabel('Actual')
    11. plt.show()

    c662478d875c4d8f8e208d589b85e405.png 

    根据上面的混淆矩阵，我们可以看到22张病毒X射线图像被预测为细菌。这可能是因为这两种肺炎类型很难区分。但是，至少我们的模型能够很好地预测细菌引起的肺炎，因为242个样本中有233个被正确分类。 

     🫥 以上是本次深度学习实战的全部解析，以下是完整代码，需要请自取：

    1. import os
    2. import cv2
    3. import pickle	# Used to save variables
    4. import numpy as np
    5. import matplotlib.pyplot as plt
    6. import seaborn as sns
    7. from tqdm import tqdm	# Used to display progress bar
    8. from sklearn.preprocessing import OneHotEncoder
    9. from sklearn.metrics import confusion_matrix
    10. from keras.models import Model, load_model
    11. from keras.layers import Dense, Input, Conv2D, MaxPool2D, Flatten
    12. from keras.preprocessing.image import ImageDataGenerator	# Used to generate images
    13.  
    14. np.random.seed(22)
    15.  
    16. # Do not forget to include the last slash
    17. def load_normal(norm_path):
    18.     norm_files = np.array(os.listdir(norm_path))
    19.     norm_labels = np.array(['normal']*len(norm_files))
    20.     
    21.     norm_images = []
    22.     for image in tqdm(norm_files):
    23. 		# Read image
    24.         if image == '.DS_Store' : continue
    25.         image = cv2.imread(norm_path + image)
    26. 		# Resize image to 200x200 px
    27.         image = cv2.resize(image, dsize=(200,200))
    28. 		# Convert to grayscale
    29.         image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    30.         norm_images.append(image)
    31.         
    32.     norm_images = np.array(norm_images)
    33.     
    34.     return norm_images, norm_labels
    35.  
    36. def load_pneumonia(pneu_path):
    37.     pneu_files = np.array(os.listdir(pneu_path))
    38.     pneu_labels = np.array([pneu_file.split('_')[1] for pneu_file in pneu_files])
    39.     
    40.     pneu_images = []
    41.     for image in tqdm(pneu_files):
    42. 		# Read image
    43.         if image == '.DS_Store' : continue
    44.         image = cv2.imread(pneu_path + image)
    45. 		# Resize image to 200x200 px
    46.         image = cv2.resize(image, dsize=(200,200))
    47. 		# Convert to grayscale
    48.         image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    49.         pneu_images.append(image)
    50.         
    51.     pneu_images = np.array(pneu_images)
    52.     
    53.     return pneu_images, pneu_labels
    54.  
    55.  
    56. print('Loading images')
    57. # All images are stored in _images, all labels are in _labels
    58. norm_images, norm_labels = load_normal('/Users/liqun/Desktop/KS/MyPython/DataSet/chest_xray/train/NORMAL/')
    59. pneu_images, pneu_labels = load_pneumonia('/Users/liqun/Desktop/KS/MyPython/DataSet/chest_xray/train/PNEUMONIA/')
    60.  
    61. # Put all train images to X_train 
    62. X_train = np.append(norm_images, pneu_images, axis=0)
    63.  
    64. # Put all train labels to y_train
    65. y_train = np.append(norm_labels, pneu_labels)
    66.  
    67. print(X_train.shape)
    68. print(y_train.shape)
    69. # Finding out the number of samples of each class
    70. print(np.unique(y_train, return_counts=True))
    71.  
    72. # print('Display several images')
    73. fig, axes = plt.subplots(ncols=7, nrows=2, figsize=(16, 4))
    74.  
    75. indices = np.random.choice(len(X_train), 14)
    76. counter = 0
    77.  
    78. for i in range(2):
    79.     for j in range(7):
    80.         axes[i,j].set_title(y_train[indices[counter]])
    81.         axes[i,j].imshow(X_train[indices[counter]], cmap='gray')
    82.         axes[i,j].get_xaxis().set_visible(False)
    83.         axes[i,j].get_yaxis().set_visible(False)
    84.         counter += 1
    85. # plt.show()
    86.  
    87.  
    88. print('Loading test images')
    89. # Do the exact same thing as what we have done on train data
    90. norm_images_test, norm_labels_test = load_normal('/Users/liqun/Desktop/KS/MyPython/DataSet/chest_xray/test/NORMAL/')
    91. pneu_images_test, pneu_labels_test = load_pneumonia('/Users/liqun/Desktop/KS/MyPython/DataSet/chest_xray/test/PNEUMONIA/')
    92. X_test = np.append(norm_images_test, pneu_images_test, axis=0)
    93. y_test = np.append(norm_labels_test, pneu_labels_test)
    94.  
    95. # Save the loaded images to pickle file for future use
    96. with open('pneumonia_data.pickle', 'wb') as f:
    97.     pickle.dump((X_train, X_test, y_train, y_test), f)
    98.  
    99. # Here's how to load it
    100. with open('pneumonia_data.pickle', 'rb') as f:
    101.     (X_train, X_test, y_train, y_test) = pickle.load(f)
    102.  
    103. print('Label preprocessing')
    104.  
    105. # Create new axis on all y data
    106. y_train = y_train[:, np.newaxis]
    107. y_test = y_test[:, np.newaxis]
    108.  
    109. # Initialize OneHotEncoder object
    110. one_hot_encoder = OneHotEncoder(sparse=False)
    111.  
    112. # Convert all labels to one-hot
    113. y_train_one_hot = one_hot_encoder.fit_transform(y_train)
    114. y_test_one_hot = one_hot_encoder.transform(y_test)
    115.  
    116. print('Reshaping X data')
    117. # Reshape the data into (no of samples, height, width, 1), where 1 represents a single color channel
    118. X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], X_train.shape[2], 1)
    119. X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], X_test.shape[2], 1)
    120.  
    121. print('Data augmentation')
    122. # Generate new images with some randomness
    123. datagen = ImageDataGenerator(
    124. 		rotation_range = 10,  
    125.         zoom_range = 0.1, 
    126.         width_shift_range = 0.1, 
    127.         height_shift_range = 0.1)
    128.  
    129. datagen.fit(X_train)
    130. train_gen = datagen.flow(X_train, y_train_one_hot, batch_size = 32)
    131.  
    132. print('CNN')
    133.  
    134. # Define the input shape of the neural network
    135. input_shape = (X_train.shape[1], X_train.shape[2], 1)
    136. print(input_shape)
    137.  
    138. input1 = Input(shape=input_shape)
    139.  
    140. cnn = Conv2D(16, (3, 3), activation='relu', strides=(1, 1), 
    141.     padding='same')(input1)
    142. cnn = Conv2D(32, (3, 3), activation='relu', strides=(1, 1), 
    143.     padding='same')(cnn)
    144. cnn = MaxPool2D((2, 2))(cnn)
    145.  
    146. cnn = Conv2D(16, (2, 2), activation='relu', strides=(1, 1), 
    147.     padding='same')(cnn)
    148. cnn = Conv2D(32, (2, 2), activation='relu', strides=(1, 1), 
    149.     padding='same')(cnn)
    150. cnn = MaxPool2D((2, 2))(cnn)
    151.  
    152. cnn = Flatten()(cnn)
    153. cnn = Dense(100, activation='relu')(cnn)
    154. cnn = Dense(50, activation='relu')(cnn)
    155. output1 = Dense(3, activation='softmax')(cnn)
    156.  
    157. model = Model(inputs=input1, outputs=output1)
    158.  
    159. model.compile(loss='categorical_crossentropy', 
    160.             optimizer='adam', metrics=['acc'])
    161.  
    162. # Using fit_generator() instead of fit() because we are going to use data
    163. # taken from the generator. Note that the randomness is changing
    164. # on each epoch
    165. history = model.fit_generator(train_gen, epochs=30, 
    166.         validation_data=(X_test, y_test_one_hot))
    167.  
    168. # Saving model
    169. model.save('pneumonia_cnn.h5')
    170.  
    171. print('Displaying accuracy')
    172. plt.figure(figsize=(8,6))
    173. plt.title('Accuracy scores')
    174. plt.plot(history.history['acc'])
    175. plt.plot(history.history['val_acc'])
    176. plt.legend(['acc', 'val_acc'])
    177. plt.show()
    178.  
    179. print('Displaying loss')
    180. plt.figure(figsize=(8,6))
    181. plt.title('Loss value')
    182. plt.plot(history.history['loss'])
    183. plt.plot(history.history['val_loss'])
    184. plt.legend(['loss', 'val_loss'])
    185. plt.show()
    186.  
    187. # Predicting test data
    188. predictions = model.predict(X_test)
    189. print(predictions)
    190.  
    191. predictions = one_hot_encoder.inverse_transform(predictions)
    192.  
    193. print('Model evaluation')
    194. print(one_hot_encoder.categories_)
    195.  
    196. classnames = ['bacteria', 'normal', 'virus']
    197.  
    198. # Display confusion matrix
    199. cm = confusion_matrix(y_test, predictions)
    200. plt.figure(figsize=(8,8))
    201. plt.title('Confusion matrix')
    202. sns.heatmap(cm, cbar=False, xticklabels=classnames, yticklabels=classnames, fmt='d', annot=True, cmap=plt.cm.Blues)
    203. plt.xlabel('Predicted')
    204. plt.ylabel('Actual')
    205. plt.show()

    🫥 本次实验所用到的数据集也为大家整理好了，从这里下载即可： 

    链接: https://pan.baidu.com/s/1h4Ve-YiXw0FyJDXCFlU1eA?pwd=qak4 提取码: qak4

    ———————————————————————————————————————————

    码字不易

    如果我的文章对你有帮助的话 麻烦留下赞哇 😋 

    感谢浏览！

     

     

     

     

  • 相关阅读:
    32位单片机GPIO端口电路结构以及输出模式
    HTML5期末大作业：游戏网站设计与实现——基于bootstrap响应式游戏资讯网站制作HTML+CSS+JavaScript
    第十二届蓝桥杯《杨辉三角》-二分法
    Python搭建http下载服务器
    【书籍篇】Git 学习指南（二）提交与多次提交
    GBase8a SSL 配置
    逃避型人格分析，如何改变逃避型性格？
    【sim-storage-client】SpringBoot集成Minio与本地存储
    nmcli 命令行设置 ipv4 ipv6 ip 网关等
    「互动有礼，感谢有你」参与互动就有机会获赠 Navicat Premium 16
  • 原文地址：https://blog.csdn.net/m0_54689021/article/details/126495422