基于改进Efficientnet的植物病虫害检测

!pip install "paddlex<=2.0.0" -i https://mirror.baidu.com/pypi/simple
!pip install prettytable

import osfrom tqdm import tqdmfrom prettytable import PrettyTableimport matplotlib.pyplot as pltimport paddleimport paddleximport paddle.nn.functional as Fimport numpy as npimport cv2import jsonimport mathimport randomfrom PIL import Imagefrom paddle.io import Dataset  # 导入Datasrt库from paddle.vision.transforms import Compose,Resize,Transpose,Normalize

if not os.path.exists("/home/aistudio/work/data"):
    ! unzip -oq data/data198683/Pests_dataset.zip -d work/data

class ConfusionMatrix(object):
    def __init__(self, num_classes: int, labels: list):
        self.matrix = np.zeros((num_classes, num_classes))
        self.num_classes = num_classes
        self.labels = labels    def update(self, preds, labels):
        for p, t in zip(preds, labels):
            self.matrix[p, t] += 1

    def summary(self):
        # calculate accuracy
        sum_TP = 0
        for i in range(self.num_classes):
            sum_TP += self.matrix[i, i]
        acc = sum_TP / np.sum(self.matrix)        print("the model accuracy is ", acc)        # precision, recall, specificity
        table = PrettyTable()
        table.field_names = ["", "Precision", "Recall", "Specificity"]        for i in range(self.num_classes):
            TP = self.matrix[i, i]
            FP = np.sum(self.matrix[i, :]) - TP
            FN = np.sum(self.matrix[:, i]) - TP
            TN = np.sum(self.matrix) - TP - FP - FN
            Precision = round(TP / (TP + FP), 3) if TP + FP != 0 else 0.
            Recall = round(TP / (TP + FN), 3) if TP + FN != 0 else 0.
            Specificity = round(TN / (TN + FP), 3) if TN + FP != 0 else 0.
            table.add_row([self.labels[i], Precision, Recall, Specificity])        print(table)    def plot(self):
        matrix = self.matrix        print(matrix)
        plt.imshow(matrix, cmap=plt.cm.Blues)        # 设置x轴坐标label
        plt.xticks(range(self.num_classes),range(self.num_classes), rotation=45)        # 设置y轴坐标label
        plt.yticks(range(self.num_classes), range(self.num_classes))        # 显示colorbar
        plt.colorbar()
        plt.xlabel('True Labels')
        plt.ylabel('Predicted Labels')
        plt.title('Confusion matrix')        # 在图中标注数量/概率信息
        thresh = matrix.max()        for x in range(self.num_classes):            for y in range(self.num_classes):                # 注意这里的matrix[y, x]不是matrix[x, y]
                info = int(matrix[y, x])
                plt.text(x, y, info,
                         verticalalignment='center',
                         horizontalalignment='center',
                         color="white" if info > thresh else "black")
        plt.tight_layout()
        plt.show()

train_list = os.listdir('work/data/Train')
train_list.sort()
class_flag = 0train_data = []
test_data = []for cls in train_list:
    num = len(os.path.join('work/data/Train', cls))    print(num)
    cls_path = os.path.join('work/data/Train', cls)
    data = [os.path.join('work/data/Train', cls, i, ','+ str(class_flag)) for i in os.listdir(cls_path)[int(0.8*num):]]    for i in data:
        train_data.append(i.split(','))
    class_flag += 1class_flag = 0for cls in train_list:
    num = len(os.path.join('work/data/Train', cls))
    cls_path = os.path.join('work/data/Train', cls)
    data = [os.path.join('work/data/Train', cls, i, ','+ str(class_flag)) for i in os.listdir(cls_path)[0:int(0.8*num)]]    for i in data:
        test_data.append(i.split(','))
    class_flag += 1with open('train.txt','w',encoding='UTF-8') as f:    for train_img in train_data:
            f.write(train_img[0][:-1] + ','+ train_img[1]+'\n')with open('test.txt','w',encoding='UTF-8') as f:    for test_img in test_data:
            f.write(test_img[0][:-1] + ','+ test_img[1]+'\n')with open('label.txt','w', encoding='UTF-8') as f:    for i in train_list:
        f.write(str(i)+'\n')print(train_list)

from paddle.io import Dataset 
os.environ["OPENCV_IO_ENABLE_OPENEXR"]="1"from paddle.vision import transforms as T


data_transforms = T.Compose([
    T.Resize((224, 224)),
    T.RandomHorizontalFlip(),
    T.ToTensor(),
    T.Normalize(mean=[0.5,0.5,0.5], std=[0.5,0.5,0.5])
])class MyDataset(Dataset):
    """
    步骤一：继承paddle.io.Dataset类
    """
    def __init__(self, mode='train'):
        """
        步骤二：实现构造函数，定义数据读取方式，划分训练和测试数据集
        """
        super(MyDataset, self).__init__()        if mode == 'train':
            self.data = train_data        else:
            self.data = test_data    def __getitem__(self, index):
        """
        步骤三：实现__getitem__方法，定义指定index时如何获取数据，并返回单条数据（训练数据，对应的标签）
        """
        data = self.data[index][0][:-1]
        label = self.data[index][1]
        image = cv2.imread(data)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image = data_transforms(image)        return image, paddle.to_tensor(int(label))    def __len__(self):
        """
        步骤四：实现__len__方法，返回数据集总数目
        """
        return len(self.data)

train_loader = paddle.io.DataLoader(MyDataset("train"), batch_size=16, shuffle=True, use_buffer_reader =True)
test_loader =  paddle.io.DataLoader(MyDataset("test"), batch_size=16, shuffle=True, use_buffer_reader =True)

from net import EfficientNetfrom net import EfficientNet_CBAM
paddle.disable_static()
epoch_num = 20batch_size = 16learning_rate = 0.005loss_value = []def train(model):
    print('start training ... ')    # turn into training mode
    model.train()

    opt = paddle.optimizer.Adam(learning_rate=learning_rate,
                                parameters=model.parameters())    for epoch in range(epoch_num):
        acc_train = []        for batch_id, data in enumerate(train_loader):
            x_data = data[0]
            y_data = paddle.to_tensor(data[1])            # y_data = paddle.unsqueeze(y_data, 1)
            logits = model(x_data)
            loss = F.cross_entropy(logits, y_data)
            acc = paddle.metric.accuracy(logits, y_data)
            acc_train.append(acc.numpy())            if batch_id % 100 == 0:                print("epoch: {}, batch_id: {}, loss is: {}".format(epoch, batch_id, loss.numpy()))
                avg_acc = np.mean(acc_train)                print("[train] accuracy: {}".format(avg_acc))
                loss_value.append(loss.numpy())
            loss.backward()
            opt.step()
            opt.clear_grad()
model = EfficientNet.from_name('efficientnet-b0')# print(paddle.flops(model,input_size=[1,3,224,224],print_detail=True))train(model)  
x1 = len(loss_value)
y1 = loss_value
paddle.save(model.state_dict(), "model.pdparams")
loss_value = []
model = EfficientNet_CBAM.from_name('efficientnet-b0')# print(paddle.flops(model,input_size=[1,3,224,224],print_detail=True))train(model)  
x2 = len(loss_value)
y2 = loss_value
paddle.save(model.state_dict(), "model_CBAM.pdparams")

plt.plot(range(x1), y1, label ='EfficientNet')
plt.plot(range(x2), y2, label ='EfficientNet_CBAM')
plt.ylabel('loss_value')
plt.xlabel('batch_size')
plt.title('loss')
plt.legend()
plt.show()

model.eval()
model.load_dict(paddle.load('model.pdparams'))


confusion = ConfusionMatrix(num_classes=7, labels=train_list)with paddle.no_grad():    for batch_id, data in enumerate(test_loader):
        x_data = data[0]
        y_data = paddle.to_tensor(data[1])
        outputs = model(x_data)
        outputs = paddle.nn.functional.softmax(outputs, axis=1)
        outputs = np.argmax(outputs, axis=1)  
        confusion.update(outputs, data[1].numpy())
    confusion.plot()
    confusion.summary()


model.load_dict(paddle.load('model_CBAM.pdparams'))with paddle.no_grad():    for batch_id, data in enumerate(test_loader):
        x_data = data[0]
        y_data = paddle.to_tensor(data[1])
        outputs = model(x_data)
        outputs = paddle.nn.functional.softmax(outputs, axis=1)
        outputs = np.argmax(outputs, axis=1)  
        confusion.update(outputs, data[1].numpy())
    confusion.plot()
    confusion.summary()

im = Image.open('work/data/Train/2_Apple___Cedar_apple_rust_train/2 (104).JPG')
plt.imshow(im)
im = data_transforms(im)
im = paddle.unsqueeze(im, axis=0)with paddle.no_grad(): #不求损失梯度，而网络默认会求损失梯度
    outputs = model(im)
    pre =paddle.nn.functional.softmax(outputs, axis=1)[0],#再次也可用softmax替代max来进行分类。print(train_list[int(np.argmax(pre[0]))])#把索引index 传给classes，得到分类