常规赛：PALM眼底彩照视盘探测与分割-8月第8名方案

class dataset(paddle.io.Dataset):
    def __init__(self,img_list,label_list,mode='train'):

        self.image=img_list
        self.label=label_list
        self.mode=mode
    def load_img(self, image_path,name):        if name=='img':
            img=cv2.imread(image_path,1)
            img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
        elif name=='label':
            img=cv2.imread(image_path,1)
            img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)            
        return img

    def __getitem__(self,index):
        img = self.load_img(self.image[index],'img')
        label = self.load_img(self.label[index],'label')

        if self.mode=='train':
            img=train_transform(img)
            label=label_transform(label)
        else:
            img=val_transform(img)
            label=label_transform(label)

      

        label=np.squeeze(label)
        label=paddle.unsqueeze(label,axis=0)
        label = np.array(label, dtype='int64')
        return img,label

        
    def __len__(self):
        return len(self.image)

import paddle.vision.transforms as Ttrain_transform=T.Compose([                        T.Resize(size=[512,512]),                       
                        T.ColorJitter(0.1, 0.1, 0.1, 0.1),                        T.Normalize(mean=[127.5, 127.5, 127.5],std=[127.5, 127.5, 127.5],data_format='HWC'),                        T.ToTensor(),
                        ])
val_transform=T.Compose([                        T.Resize(size=[512,512]),                        T.Normalize(mean=[127.5, 127.5, 127.5],std=[127.5, 127.5, 127.5],data_format='HWC'),                        T.ToTensor(),
                        ])
label_transform=T.Compose([                        T.Resize(size=[512,512]),                        T.Normalize(mean=[0],std=[255],data_format='HWC'),                        T.ToTensor(),
                        ])

lr = paddle.optimizer.lr.CosineAnnealingDecay(learning_rate=1e-4,                                                T_max=step_each_epoch * EPOCHS)

!unzip -oq /home/aistudio/data/data102827/常规赛：PALM眼底彩照视盘探测与分割.zip

!rm -fr __MACOSX

import ioimport cv2import osimport matplotlib.pyplot as pltimport numpy as npimport paddle

train_path='常规赛：PALM眼底彩照视盘探测与分割/Train/fundus_image/' train_label_path='常规赛：PALM眼底彩照视盘探测与分割/Train/Disc_Masks/'train_list = os.listdir(train_path)
images=[]
labels=[]
label_list=[]
image_list=[]for i in range(len(train_list)):
    images.append(train_path+train_list[i])
    labels.append(train_label_path+train_list[i][:-3]+'bmp')
    image_list.append(train_path+train_list[i])
    label_list.append(train_label_path+train_list[i][:-3]+'bmp')

test_path='常规赛：PALM眼底彩照视盘探测与分割/PALM-Testing400-Images/'test_list = os.listdir(test_path)
test_images=[]
test_label=[]
test_size=[]for i in range(len(test_list)):
    test_images.append(test_path+test_list[i])
    test_label.append(train_label_path+train_list[0][:-3]+'bmp')
    img=cv2.imread(test_path+test_list[i])
    test_size.append(img.shape)

test_size=np.array(test_size)

def write_file(mode, images, labels):
    with open('./{}.txt'.format(mode), 'w') as f:        for i in range(len(images)):
            f.write('{}\t{}\n'.format(images[i], labels[i]))

eval_num = int(len(images) * 0.15)
write_file('train', images[:-eval_num], labels[:-eval_num])
write_file('test', images[-eval_num:], labels[-eval_num:])
write_file('predict', images[-eval_num:], labels[-eval_num:])

from PIL import Image as PilImageimport numpy as npimport matplotlib.pyplot as pltwith open('./train.txt', 'r') as f:
    i = 0

    for line in f.readlines():
        image_path, label_path = line.strip().split('\t')
        image = np.array(PilImage.open(image_path))
        label = np.array(PilImage.open(label_path))    
        if i > 2:            break
        # 进行图片的展示
        plt.figure()

        plt.subplot(1,2,1), 
        plt.title('Train Image')
        plt.imshow(image.astype('uint8'))
        plt.axis('off')

        plt.subplot(1,2,2), 
        plt.title('Label')
        plt.imshow(label.astype('uint8'), cmap='gray')
        plt.axis('off')

        plt.show()
        i = i + 1

import paddle.vision.transforms as T
train_transform=T.Compose([
                        T.Resize(size=[512,512]),                       
                        T.ColorJitter(0.1, 0.1, 0.1, 0.1),

                        T.Normalize(mean=[127.5, 127.5, 127.5],std=[127.5, 127.5, 127.5],data_format='HWC'),
                        T.ToTensor(),
                        ])
val_transform=T.Compose([
                        T.Resize(size=[512,512]),
                        T.Normalize(mean=[127.5, 127.5, 127.5],std=[127.5, 127.5, 127.5],data_format='HWC'),
                        T.ToTensor(),
                        ])
label_transform=T.Compose([
                        T.Resize(size=[512,512]),

                        T.Normalize(mean=[0],std=[255],data_format='HWC'),
                        T.ToTensor(),
                        ])

import matplotlib.pyplot as pltimport cv2import numpy as np
img1=cv2.imread(label_list[1],1)
img1=cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY)



plt.imshow(img1,'gray')
plt.show()


img1=label_transform(img1)

img1=np.squeeze(img1)print(img1.shape)
img1=img1.transpose([1,2,0])

plt.imshow(img1,'gray')
plt.show()

img2=cv2.imread(image_list[1],1)
img2=cv2.cvtColor(img2,cv2.COLOR_BGR2RGB)
img2=train_transform(img2)
img2=img2.transpose([1,2,0])
plt.imshow(img2)
plt.show()##img3=cv2.addWeighted(img4,0.1,img2,0.9,0)#plt.imshow(img3)#plt.show()

import paddleimport numpy as npclass dataset(paddle.io.Dataset):
    def __init__(self,img_list,label_list,mode='train'):

        self.image=img_list
        self.label=label_list
        self.mode=mode    def load_img(self, image_path,name):
        if name=='img':
            img=cv2.imread(image_path,1)
            img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)        elif name=='label':
            img=cv2.imread(image_path,1)
            img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)            
        return img    def __getitem__(self,index):
        img = self.load_img(self.image[index],'img')
        label = self.load_img(self.label[index],'label')        if self.mode=='train':
            img=train_transform(img)
            label=label_transform(label)        else:
            img=val_transform(img)
            label=label_transform(label)

      

        label=np.squeeze(label)
        label=paddle.unsqueeze(label,axis=0)
        label = np.array(label, dtype='int64')        return img,label        
    def __len__(self):
        return len(self.image)

import randomfrom paddle.io import Datasetfrom paddle.vision.transforms import transforms as Tclass PetDataset(Dataset):
    """
    数据集定义
    """
    def __init__(self, mode='train'):
        """
        构造函数
        """
        self.image_size = IMAGE_SIZE
        self.mode = mode.lower()        
        assert self.mode in ['train', 'test', 'predict'], \            "mode should be 'train' or 'test' or 'predict', but got {}".format(self.mode)
        
        self.train_images = []
        self.label_images = []        with open('./{}.txt'.format(self.mode), 'r') as f:            for line in f.readlines():
                image, label = line.strip().split('\t')
                self.train_images.append(image)
                self.label_images.append(label)        
    def _load_img(self, path, color_mode='rgb', transforms=[]):
        """
        统一的图像处理接口封装，用于规整图像大小和通道
        """
        with open(path, 'rb') as f:
            img = PilImage.open(io.BytesIO(f.read()))            if color_mode == 'grayscale':                # if image is not already an 8-bit, 16-bit or 32-bit grayscale image
                # convert it to an 8-bit grayscale image.
                if img.mode not in ('L', 'I;16', 'I'):
                    img = img.convert('L')            elif color_mode == 'rgba':                if img.mode != 'RGBA':
                    img = img.convert('RGBA')            elif color_mode == 'rgb':                if img.mode != 'RGB':
                    img = img.convert('RGB')            else:                raise ValueError('color_mode must be "grayscale", "rgb", or "rgba"')            
            return T.Compose([
                T.Resize(self.image_size)
            ] + transforms)(img)    def __getitem__(self, idx):
        """
        返回 image, label
        """
        train_image = self._load_img(self.train_images[idx], 
                                     transforms=[
                                         T.Transpose(), 
                                         T.Normalize(mean=127.5, std=127.5)
                                     ]) # 加载原始图像
        label_image = self._load_img(self.label_images[idx], 
                                     color_mode='grayscale',
                                     transforms=[T.Grayscale()]) # 加载Label图像
    
        # 返回image, label
        train_image = np.array(train_image, dtype='float32')
        label_image = np.array(label_image, dtype='int64')        return train_image, label_image        
    def __len__(self):
        """
        返回数据集总数
        """
        return len(self.train_images)

from paddle.nn import functional as Fimport paddleclass SeparableConv2D(paddle.nn.Layer):
    def __init__(self, 
                 in_channels, 
                 out_channels, 
                 kernel_size, 
                 stride=1, 
                 padding=0, 
                 dilation=1, 
                 groups=None, 
                 weight_attr=None, 
                 bias_attr=None, 
                 data_format="NCHW"):
        super(SeparableConv2D, self).__init__()

        self._padding = padding
        self._stride = stride
        self._dilation = dilation
        self._in_channels = in_channels
        self._data_format = data_format        # 第一次卷积参数，没有偏置参数
        filter_shape = [in_channels, 1] + self.convert_to_list(kernel_size, 2, 'kernel_size')
        self.weight_conv = self.create_parameter(shape=filter_shape, attr=weight_attr)        # 第二次卷积参数
        filter_shape = [out_channels, in_channels] + self.convert_to_list(1, 2, 'kernel_size')
        self.weight_pointwise = self.create_parameter(shape=filter_shape, attr=weight_attr)
        self.bias_pointwise = self.create_parameter(shape=[out_channels], 
                                                    attr=bias_attr, 
                                                    is_bias=True)    
    def convert_to_list(self, value, n, name, dtype=np.int):
        if isinstance(value, dtype):            return [value, ] * n        else:            try:
                value_list = list(value)            except TypeError:                raise ValueError("The " + name +                                "'s type must be list or tuple. Received: " + str(
                                    value))            if len(value_list) != n:                raise ValueError("The " + name + "'s length must be " + str(n) +                                ". Received: " + str(value))            for single_value in value_list:                try:
                    dtype(single_value)                except (ValueError, TypeError):                    raise ValueError(                        "The " + name + "'s type must be a list or tuple of " + str(
                            n) + " " + str(dtype) + " . Received: " + str(
                                value) + " "
                        "including element " + str(single_value) + " of type" + " "
                        + str(type(single_value)))            return value_list    
    def forward(self, inputs):
        conv_out = F.conv2d(inputs, 
                            self.weight_conv, 
                            padding=self._padding,
                            stride=self._stride,
                            dilation=self._dilation,
                            groups=self._in_channels,
                            data_format=self._data_format)
        
        out = F.conv2d(conv_out,
                       self.weight_pointwise,
                       bias=self.bias_pointwise,
                       padding=0,
                       stride=1,
                       dilation=1,
                       groups=1,
                       data_format=self._data_format)        return out

class Encoder(paddle.nn.Layer):
    def __init__(self, in_channels, out_channels):
        super(Encoder, self).__init__()
        
        self.relus = paddle.nn.LayerList(
            [paddle.nn.ReLU() for i in range(2)])
        self.separable_conv_01 = SeparableConv2D(in_channels, 
                                                 out_channels, 
                                                 kernel_size=3, 
                                                 padding='same')
        self.bns = paddle.nn.LayerList(
            [paddle.nn.BatchNorm2D(out_channels) for i in range(2)])
        
        self.separable_conv_02 = SeparableConv2D(out_channels, 
                                                 out_channels, 
                                                 kernel_size=3, 
                                                 padding='same')
        self.pool = paddle.nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
        self.residual_conv = paddle.nn.Conv2D(in_channels, 
                                              out_channels, 
                                              kernel_size=1, 
                                              stride=2, 
                                              padding='same')    def forward(self, inputs):
        previous_block_activation = inputs
        
        y = self.relus[0](inputs)
        y = self.separable_conv_01(y)
        y = self.bns[0](y)
        y = self.relus[1](y)
        y = self.separable_conv_02(y)
        y = self.bns[1](y)
        y = self.pool(y)
        
        residual = self.residual_conv(previous_block_activation)
        y = paddle.add(y, residual)        return y

class Decoder(paddle.nn.Layer):
    def __init__(self, in_channels, out_channels):
        super(Decoder, self).__init__()

        self.relus = paddle.nn.LayerList(
            [paddle.nn.ReLU() for i in range(2)])
        self.conv_transpose_01 = paddle.nn.Conv2DTranspose(in_channels, 
                                                           out_channels, 
                                                           kernel_size=3, 
                                                           padding=1)
        self.conv_transpose_02 = paddle.nn.Conv2DTranspose(out_channels, 
                                                           out_channels, 
                                                           kernel_size=3, 
                                                           padding=1)
        self.bns = paddle.nn.LayerList(
            [paddle.nn.BatchNorm2D(out_channels) for i in range(2)]
        )
        self.upsamples = paddle.nn.LayerList(
            [paddle.nn.Upsample(scale_factor=2.0) for i in range(2)]
        )
        self.residual_conv = paddle.nn.Conv2D(in_channels, 
                                              out_channels, 
                                              kernel_size=1, 
                                              padding='same')    def forward(self, inputs):
        previous_block_activation = inputs

        y = self.relus[0](inputs)
        y = self.conv_transpose_01(y)
        y = self.bns[0](y)
        y = self.relus[1](y)
        y = self.conv_transpose_02(y)
        y = self.bns[1](y)
        y = self.upsamples[0](y)
        
        residual = self.upsamples[1](previous_block_activation)
        residual = self.residual_conv(residual)
        
        y = paddle.add(y, residual)        
        return y

class PetNet(paddle.nn.Layer):
    def __init__(self, num_classes):
        super(PetNet, self).__init__()

        self.conv_1 = paddle.nn.Conv2D(3, 32, 
                                       kernel_size=3,
                                       stride=2,
                                       padding='same')
        self.bn = paddle.nn.BatchNorm2D(32)
        self.relu = paddle.nn.ReLU()

        in_channels = 32
        self.encoders = []
        self.encoder_list = [64, 128, 256]
        self.decoder_list = [256, 128, 64, 32]        # 根据下采样个数和配置循环定义子Layer，避免重复写一样的程序
        for out_channels in self.encoder_list:
            block = self.add_sublayer('encoder_{}'.format(out_channels),
                                      Encoder(in_channels, out_channels))
            self.encoders.append(block)
            in_channels = out_channels

        self.decoders = []        # 根据上采样个数和配置循环定义子Layer，避免重复写一样的程序
        for out_channels in self.decoder_list:
            block = self.add_sublayer('decoder_{}'.format(out_channels), 
                                      Decoder(in_channels, out_channels))
            self.decoders.append(block)
            in_channels = out_channels

        self.output_conv = paddle.nn.Conv2D(in_channels, 
                                            num_classes, 
                                            kernel_size=3, 
                                            padding='same')    


    def forward(self, inputs):
        y = self.conv_1(inputs)
        y = self.bn(y)
        y = self.relu(y)        
        for encoder in self.encoders:
            y = encoder(y)        for decoder in self.decoders:
            y = decoder(y)
        
        y = self.output_conv(y)        return y

IMAGE_SIZE = (512, 512)
num_classes =4network = PetNet(num_classes)
model = paddle.Model(network)
model.summary((-1, 3,) + IMAGE_SIZE)

radio=0.9train_ds =dataset(image_list[:int(len(image_list)*radio)],label_list[:int(len(label_list)*radio)],'train')
val_ds=dataset(image_list[int(len(image_list)*radio):],label_list[int(len(label_list)*radio):],'valid')

train_loader = paddle.io.DataLoader(train_ds, places=paddle.CPUPlace(), batch_size=32, shuffle=True, num_workers=0)
val_loader = paddle.io.DataLoader(val_ds, places=paddle.CPUPlace(), batch_size=32, shuffle=False, num_workers=0)#test_dataset=dataset(test_list,test_label,'test')

test_ds =dataset(test_images,test_label,'test')
test_loader = paddle.io.DataLoader(test_ds, places=paddle.CPUPlace(), batch_size=32, shuffle=False, num_workers=0)

for id,data in enumerate(train_ds):    print('aaaaaaaaaaaaaaaaaaa')
    img,lb=data    print(lb.shape)    print(lb)
    lb=lb.reshape(512,512)
    plt.imshow(lb)    break

train_ds = PetDataset(mode='train') # 训练数据集val_ds = PetDataset(mode='test') # 验证数据集

network = PetNet(num_classes)
model = paddle.Model(network)#model.load('/home/aistudio/work/lup/final')Batch_size=32EPOCHS=15step_each_epoch = len(train_ds)//Batch_size


lr = paddle.optimizer.lr.CosineAnnealingDecay(learning_rate=1e-4,
                                                T_max=step_each_epoch * EPOCHS)# 定义Adam优化器optimizer = paddle.optimizer.Adam(learning_rate=lr,
                                weight_decay=1e-5,
                                parameters=model.parameters())

model.prepare(optimizer, paddle.nn.CrossEntropyLoss(axis=1))


model.fit(train_loader, 
          val_loader, 
          epochs=EPOCHS, 
          batch_size=Batch_size,
          save_dir="/home/aistudio/work/lup", #把模型参数、优化器参数保存至自定义的文件夹
          save_freq=1,                    #设定每隔多少个epoch保存模型参数及优化器参数          
          verbose=1)

model.load('/home/aistudio/work/lup/final')
result = model.predict(test_loader)

pred=[]for i in range(len(result[0])):
    pred.extend(result[0][i])

im=pred[2].transpose([1,2,0])print(im.shape)print(im.dtype)


mask = np.argmax(im, axis=-1)*255plt.imshow(mask.astype('uint8'), cmap='gray')
plt.show()print(mask)

print(test_size)

from paddle.vision.transforms import Resize

result_list = os.listdir('Disc_Segmentation')for i in range(len(result_list)):
    os.remove('Disc_Segmentation/'+result_list[i])for i in range(len(pred)):
    
    
    img=pred[i].transpose([1,2,0])
    img=cv2.resize(img,tuple([test_size[i][1],test_size[i][0]]))

    img = np.argmax(img, axis=-1)*255
    #_,img = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY_INV)

 


    cv2.imwrite('/home/aistudio/Disc_Segmentation/'+test_list[i][:-4]+'.png',img)

!zip -r Disc_Segmentation.zip 'Disc_Segmentation'