新冠肺炎患者图像分类

 import os

    
 import math
    
 import zipfile
    
 import random
    
 import json
    
 import cv2
    
 import numpy as np
    
 from PIL import Image
    
 import paddle
    
 import paddle.fluid as fluid
    
 from paddle.fluid.dygraph import Linear,Conv2D,Pool2D
    
 import matplotlib.pyplot as plt
    
 paddle.enable_static()

 #创建执行器

    
 place=fluid.CPUPlace()
    
 exe=fluid.Executor(place)
    
 exe.run(fluid.default_startup_program())

 #加载之前的params_model模型，没有模型就不加载

    
 save_path='save_model'
    
 if os.path.exists(save_path):
    
 	print("使用参数模型作为预训练模型")
    
 	fluid.io.load_params(executor=exe,dirname=save_path)

 save_path='save_model'

    
 #从模型中得到预测程序，输入数据名称列表和分类器
    
 [infer_program,feeded_var_names,target_var]=fluid.io.load_inference_model(dirname=save_path,executor=exe)

 #一些参数的设置

    
 configs = {
    
     "input_size": [3, 1024,1024],                           #输入图片的shape
    
     "class_dim":3,                                     #分类数
    
     'src_path':'data/data82373/input_data.rar',     #数据的路径
    
     'train_path':'input_data',                #解压路径
    
     'model_save_dir':'save_model',       # 模型保存路径
    
     'learning_rate':0.001,          #学习率
    
     'batch_size':32,               #批次大小
    
     'epoch':10                    #学习次数
    
 }

 #预处理图片，获取训练和测试的数据集

    
  
    
 COVID =[] #新冠肺炎患者的胸透图片
    
 COVID_label = []
    
  
    
 NORMAL = [] #正常人的胸透图片
    
 NORMAL_label = []
    
  
    
 Viral_Pneumonia = [] #病毒性肺炎患者的胸透图片
    
 Viral_Pneumonia_label = []
    
  
    
 # 获取所以图片的路径名
    
 # 对应的列表中，同时贴上标签，存放到label列表中
    
 def get_files(file_path, ratio):
    
     for file in os.listdir(file_path + '/COVID'):
    
     COVID.append(file_path + '/COVID' + '/' + file)
    
     COVID_label.append(0)   # 0为新冠肺炎患者
    
     for file in os.listdir(file_path + '/NORMAL'):
    
     NORMAL.append(file_path + '/NORMAL' + '/' + file)
    
     NORMAL_label.append(1)  # 1为正常人
    
     for file in os.listdir(file_path + '/Viral_Pneumonia'):
    
     Viral_Pneumonia.append(file_path + '/Viral_Pneumonia' + '/' + file)
    
     Viral_Pneumonia_label.append(2)     # 2为病毒性肺炎患者
    
  
    
     #检测是否读取成功
    
     for i in range(1):
    
     # 解决中文显示问题
    
     plt.rcParams['font.sans-serif'] = ['SimHei']
    
     plt.rcParams['axes.unicode_minus'] = False
    
     img = plt.imread(NORMAL[i+5])
    
     plt.title('图片的类型是:'+str(NORMAL_label[i+5]))
    
     plt.imshow(img)
    
     plt.show()
    
  
    
     #将新路径的图片进行打乱处理
    
     image_list = np.hstack((COVID, NORMAL, Viral_Pneumonia))
    
     label_list = np.hstack((COVID_label, NORMAL_label, Viral_Pneumonia_label))
    
  
    
     # 利用shuffle打乱顺序
    
     temp = np.array([image_list, label_list])
    
     temp = temp.transpose()
    
     np.random.shuffle(temp)
    
  
    
     # 将所有的img和lab转换成list
    
     all_image_list = list(temp[:, 0])
    
     all_label_list = list(temp[:, 1])
    
  
    
     # 将所得List分为两部分，一部分用来训练tra，一部分用来测试val
    
     # ratio是测试集的比例,看情况填入0-1的一个小数
    
     n_sample = len(all_label_list)
    
  
    
     n_val = int(math.ceil(n_sample * ratio))  # 测试样本数
    
     n_train = n_sample - n_val  # 训练样本数
    
  
    
     tra_images = all_image_list[0:n_train]
    
     tra_labels = all_label_list[0:n_train]
    
     tra_labels = [int(float(i)) for i in tra_labels]
    
  
    
     val_images = all_image_list[n_train:-1]
    
     val_labels = all_label_list[n_train:-1]
    
     val_labels = [int(float(i)) for i in val_labels]
    
  
    
     return tra_images, tra_labels, val_images, val_labels

 #自定义读取数据函数

    
  
    
 def data_reader(images,labels):
    
     '''
    
     自定义data_reader
    
     '''
    
     def reader():
    
         for item in range(len(images)):
    
             img_path = images[item]
    
             lab = labels[item] 
    
             img = cv2.imread(img_path)
    
             img = np.resize(img,(3,256,256))
    
             img = np.array(img).reshape(3,256,256).astype('float32') #要reshape一下，因为输入数据的格式是[256,256,3]，而paddle接受数据格式是[3,256,256]
    
             img = img/255.0
    
             yield img, int(lab)
    
     return reader

 # 定义训练的模型

    
  
    
 def CNN_model(tra_images):
    
     # 第一个卷积-池化层
    
     conv_pool_1 = fluid.nets.simple_img_conv_pool(
    
     input=tra_images,         # 输入图像
    
     filter_size=5,     # 滤波器的大小
    
     num_filters=20,    # filter 的数量。它与输出的通道相同
    
     pool_size=2,       # 池化核大小2*2
    
     pool_stride=2,     # 池化步长   
    
     act="relu")        # 激活类型
    
     conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)
    
     # 第二个卷积-池化层
    
     conv_pool_2 = fluid.nets.simple_img_conv_pool(
    
     input=conv_pool_1,
    
     filter_size=5,
    
     num_filters=50,
    
     pool_size=2,
    
     pool_stride=2,
    
     act="relu")
    
     conv_pool_2 = fluid.layers.batch_norm(conv_pool_2)
    
     # 第三个卷积-池化层
    
     conv_pool_3 = fluid.nets.simple_img_conv_pool(
    
     input=conv_pool_2,
    
     filter_size=5,
    
     num_filters=50,
    
     pool_size=2,
    
     pool_stride=2,
    
     act="relu")
    
     # 以softmax为激活函数的全连接输出层，因为是分成三类，所以size是三
    
     prediction = fluid.layers.fc(input=conv_pool_3, size=3, act='softmax')
    
     return prediction

 data_shape = [3,256,256]

    
 tra_images = fluid.layers.data(name='image', shape=data_shape, dtype='float32')
    
 label = fluid.layers.data(name='label', shape=[1], dtype='int64')
    
 # 获取分类器，用cnn进行分类
    
  
    
 #model = paddle.vision.models.resnet50(pretrained=True,num_classes=3)
    
 #predict = model(tra_images)
    
 predict =  CNN_model(tra_images)
    
  
    
 print(np.shape(predict))
    
 # 获取损失函数和准确率
    
 cost = fluid.layers.cross_entropy(input=predict, label=label) # 交叉熵
    
 avg_cost = fluid.layers.mean(cost)                            # 计算cost中所有元素的平均值
    
 acc = fluid.layers.accuracy(input=predict, label=label)       #使用输入和标签计算准确率
    
  
    
 # 定义优化方法
    
 optimizer =fluid.optimizer.Adam(learning_rate=configs['learning_rate'])
    
 optimizer.minimize(avg_cost)
    
 print("完成")

 #克隆用于测试模型

    
 test_program = fluid.default_main_program().clone(for_test=True)

 feeder = fluid.DataFeeder(feed_list=[tra_images, label],place=place)

    
 all_train_iter=0
    
 all_train_iters=[]
    
 all_train_costs=[]
    
 all_train_accs=[]
    
  
    
 #定义数据读取
    
 data_shape = configs['input_size']
    
 train_image, train_label, val_image, val_label =get_files(configs['train_path'], 0.8)
    
 print(type(train_image[0]))
    
 train_reader = paddle.batch(data_reader(train_image,train_label),
    
                         batch_size=configs['batch_size'],
    
                         drop_last=True)
    
 eval_reader = paddle.batch(data_reader(val_image,val_label),
    
                         batch_size=configs['batch_size'],
    
                         drop_last=True)
    
 test_reader = paddle.batch(data_reader(val_image,val_label),
    
                         batch_size=1,
    
                         drop_last=True)

 label_list = ['新冠肺炎患者','正常人','病毒性肺炎患者']

    
 for j in range(len(val_image)):
    
  
    
     for batch_id, data in enumerate(eval_reader()):
    
         results = exe.run(program=test_program,                 #运行预测程序
    
                             feed=feeder.feed(data),  #喂入要预测的img
    
                             fetch_list=predict)          #得到推测结果
    
         #print(results)
    
         results_list = results[0].tolist()
    
         #print(results_list)
    
         for i in range(len(results_list)):
    
             plt.rcParams['font.sans-serif'] = ['SimHei'] # 设置中文
    
             plt.rcParams['axes.unicode_minus'] = False
    
             img = plt.imread(val_image[i])
    
             plt.title('图片的类型是:'+str(val_label[i]))
    
             plt.imshow(img)
    
             plt.show()
    
  
    
             predict_result=label_list[np.argmax(results_list[i])]
    
             print("预测结果为: \n", predict_result)
    
             print('------------------------------------')
    
             if  i ==5: #根据自己想查看多少张，可以修改这个i的值
    
                 break
    
         break
    
     break