【AI达人训练营】基于飞桨高层 API 实现草莓生长阶段识别

#!unzip -oq /home/aistudio/data/data104406/data666.zip

import osimport pandas as pdimport numpy as npfrom PIL import Image#from sklearn.utils import shuffleimport warnings
warnings.filterwarnings("ignore")

df = pd.read_csv('data666/train.csv')
df = df.sample(frac=1).reset_index(drop=True)
df.to_csv('train.csv',header=1,index=0 )

d=df['label'].hist().get_figure()
d.savefig('1.jpg')

import paddleimport paddle.nn as nnfrom paddle.io import Datasetimport paddle.vision.transforms as Timport paddle.nn.functional as Ffrom paddle.metric import Accuracy

# 划分训练集和校验集df = pd.read_csv('train.csv')
all_size = len(df)
train_size = int(all_size * 0.8)

train_image_list = df[:train_size]
val_image_list = df[train_size:]


train_image_path_list = df['image'].values
label_list = df['label'].values

label_list = paddle.to_tensor(label_list, dtype='int64')
train_label_list = paddle.nn.functional.one_hot(label_list, num_classes=4)


val_image_path_list = val_image_list['image'].values
val_label_list = val_image_list['label'].values

val_label_list = paddle.to_tensor(val_label_list, dtype='int64')
val_label_list = paddle.nn.functional.one_hot(val_label_list, num_classes=4)

# 定义数据预处理data_transforms = T.Compose([
    T.Resize(size=(224, 224)),
    T.RandomHorizontalFlip(224),
    T.RandomVerticalFlip(224),
    T.Transpose(),    # HWC -> CHW
    T.Normalize(
        mean=[0, 0, 0],        # 归一化
        std=[255, 255, 255],
        to_rgb=True)    
])

def __init__(self): 主要是数据获取，如：某文件中获取；

def __len__(self): 整个数据集的长度；

def __getitem__(self,index): 编写支持数据集索引的函数；

https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/io/Dataset_cn.html#dataset

https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/io/DataLoader_cn.html

# 构建Datasetclass MyDataset(paddle.io.Dataset):
    """
    步骤一：继承paddle.io.Dataset类
    """
    def __init__(self, train_img_list, val_img_list,train_label_list,val_label_list, mode='train'):
        """
        步骤二：实现构造函数，定义数据读取方式，划分训练和测试数据集
        """
        super(MyDataset, self).__init__()
        self.img = []
        self.label = []        # 借助pandas读csv的库
        self.train_images = train_img_list
        self.test_images = val_img_list
        self.train_label = train_label_list
        self.test_label = val_label_list        if mode == 'train':            # 读train_images的数据
            for img,lab in zip(self.train_images, self.train_label):#并行遍历for x,y in zip(list1,list2)
                self.img.append('data666/train/'+img)
                self.label.append(lab)        else:            # 读test_images的数据
            for img,lab in zip(self.test_images, self.test_label):
                self.img.append('data666/train/'+img)
                self.label.append(lab)    def load_img(self, image_path):
        image = Image.open(image_path).convert('RGB')        return image    def __getitem__(self, index):
        """
        步骤三：实现__getitem__方法，定义指定index时如何获取数据，并返回单条数据（训练数据，对应的标签）
        """
        image = self.load_img(self.img[index])
        label = self.label[index]        
        return data_transforms(image), paddle.nn.functional.label_smooth(label)    def __len__(self):
        """
        步骤四：实现__len__方法，返回数据集总数目
        """
        return len(self.img)

#train_loadertrain_dataset = MyDataset(train_img_list=train_image_path_list, val_img_list=val_image_path_list, train_label_list=train_label_list, val_label_list=val_label_list, mode='train')
train_loader = paddle.io.DataLoader(train_dataset, places=paddle.CPUPlace(), batch_size=32, shuffle=True, num_workers=0)#val_loaderval_dataset = MyDataset(train_img_list=train_image_path_list, val_img_list=val_image_path_list, train_label_list=train_label_list, val_label_list=val_label_list, mode='test')
val_loader = paddle.io.DataLoader(train_dataset, places=paddle.CPUPlace(), batch_size=32, shuffle=True, num_workers=0)# paddle.io.DataLoader()
    # dataset: 加载数据，此参数必须是 paddle.io.Dataset
    # places:   数据需要放置到的Place列表。在静态图和动态图模式中，此参数均必须设置。在动态图模式中，此参数列表长度必须是1。默认值为None
                    # CPUPlace 是一个设备描述符，指定 CPUPlace 则 Tensor 将被自动分配在该设备上，并且模型将会运行在该设备上。
    # batch_size: 每mini-batch中样本个数
    # shuffle:  生成mini-batch索引列表时是否对索引打乱顺序
    # num_workers: 用于加载数据的子进程个数，若为0即为不开启子进程，在主进程中进行数据加载。默认值为0

from paddle.vision.models import resnet50

model_resnet50 = paddle.vision.models.resnet50(pretrained=False, num_classes=4)
model = paddle.Model(model_resnet50)#model.summary((1,3,224,224))#打印

optim = paddle.optimizer.Adam(learning_rate=0.0003, parameters=model.parameters())

model.prepare(
    optim,
    paddle.nn.CrossEntropyLoss(soft_label=True),
    Accuracy()
    )

model.fit(train_loader,
        val_loader,
        epochs=10,
        batch_size=32,
        verbose=1,
        )

model.save('Res', False)  # save for inference

model.prepare()

#上传样本图片并解压#!unzip -oq /home/aistudio/sample.zip

def load_image(file):
        # 打开图片
        im = Image.open(file)        # 将图片调整为跟训练数据一样的大小  224*224
        im = im.resize((224, 224), Image.ANTIALIAS)        # 建立图片矩阵 类型为float32
        im = np.array(im).astype(np.float32)        # 矩阵转置 
        im = im.transpose((2, 0, 1))                               
        # 将像素值从[0-255]转换为[0-1]
        im = im /255.0

        im = np.expand_dims(im, axis=0)        # 保持和之前输入image维度一致
        print('im_shape的维度：',im.shape)        return im

import matplotlib.pyplot as plt# 定义标签，列表形式label_list = [ "草莓生长期", "草莓开花期", "草莓结果期", "草莓成熟期"]## 读入测试图infer_path='/home/aistudio/sample/test_7.jpg'img = Image.open(infer_path)
plt.imshow(img)   
plt.show()    

# 载入预测图infer_img = load_image(infer_path)# 图片转数组infer_img=np.array(infer_img).astype('float32')
infer_img = np.expand_dims(infer_img, axis=0)#增加维度，否则报错# 预测result = model.predict(infer_img)# 输出结果print('results',result)print("infer results: %s" % label_list[np.argmax(result[0][0])])

def load_image(img_path):
    '''
    预测图片预处理
    '''
    img = Image.open(img_path).convert('RGB')    
    #resize
    img = img.resize((224, 224), Image.BILINEAR) #双线性插值
    img = np.array(img).astype('float32')    # HWC to CHW 
    img = img.transpose((2, 0, 1))    
    #Normalize
    img = img / 255 #像素归一
    
    return imgdef infer_img(path, model_file_path, use_gpu):
    '''
    模型预测
    '''
    paddle.set_device('gpu:0') if use_gpu else paddle.set_device('cpu')
    model = paddle.jit.load(model_file_path)
    model.eval() 

    #对预测图片进行预处理
    infer_imgs = []
    infer_imgs.append(load_image(path))
    infer_imgs = np.array(infer_imgs)
    label_list = ['0:生长', '1:开花', '2:结果', '3:成熟']
    label_pre = []    for i in range(len(infer_imgs)):
        data = infer_imgs[i]
        dy_x_data = np.array(data).astype('float32')
        dy_x_data = dy_x_data[np.newaxis,:, : ,:]#增加维度
        img = paddle.to_tensor(dy_x_data)
        out = model(img)

        lab = np.argmax(out.numpy())  #argmax():返回最大数的索引
        label_pre.append(lab)       
    return label_pre

img_list = os.listdir('/home/aistudio/data666/test/testA')
img_list.sort(key=lambda x: int(x[5:-4]))    #将‘.jpg’左边的字符转换成整数型进行排序

pre_list = []for i in range(len(img_list)):
    pre_list.append(infer_img(path='data666/test/testA/' + img_list[i], use_gpu=True, model_file_path="Res")[0])

img = pd.DataFrame(img_list)
img = img.rename(columns = {0:"image"})
img['label'] = pre_list

img.to_csv('submit_Res.csv', index=False)