ResNet及BCD版本详解且在眼疾识别中应用实例

def forword(x):
    # 路径1：表示短接步骤
    identity_x=x 
    # 路径2：表示残差部分，weight_layer和relu分别表示常见的卷积操作和relu函数处理
    Fx=weight_layer(x)
    Fx=relu(Fx)
    Fx=weight_layer(x)    # 对两条路径进行加和，然后实现非线性化输出
    output=Fx+identity_x
    output=relu(output)    return output

def forword(x):
    # 路径1：表示关联通道，其映射方式为identity(x)，在路径2的输入和输出形状相同时短接，返回值为x，在形状不同时，对x进行映射来达到一致
    identity_x=identity_x(x)    # 路径2：表示残差映射，用F(x)来表示
    Fx=F(x)    # 对两条路径进行加和，然后进行非线性化输出
    output=Fx+identity_x
    output=relu(output)    return output

# Rasicblock结构中Fxdef forword(x):
    x=conv3x3(x)
    x=relu(x)
    x=conv3x3(x)    return x# BottleNeck结构中的Fxdef forword(x):
    x=conv1x1(x)
    x=relu(x)
    x=conv3x3(x)
    x=relu(x)
    x=conv1x1(x)    return x

import paddleimport paddle.nn as nnimport numpy as npprint(paddle.__version__)

# 定义卷积BN块class ConvBNLayer(nn.Layer):
    def __init__(self,
                 num_channels,
                 num_filters,
                 filter_size,
                 stride=1,
                 groups=1,
                 act='relu'):
        super(ConvBNLayer,self).__init__()
        self._conv=nn.Conv2D(
            in_channels=num_channels,
            out_channels=num_filters,
            kernel_size=filter_size,
            stride=stride,
            padding=(filter_size-1)//2,# 确保下采样和尺寸不变
            groups=groups,
            bias_attr=False,
        )
        self._batch_norm=nn.BatchNorm2D(num_filters)
        self.act=act    def forward(self,inputs):
        x=self._conv(inputs)
        x=self._batch_norm(x)        if self.act=='leaky':
            x=nn.functional.leaky_relu(x=x,negative_slope=0.1)        elif self.act=='relu':
            x=nn.functional.relu(x=x)        return x

# 定义残差块# 每个残差块会对输入图片做三次卷积，然后跟输入图片进行短接# 如果残差块中第三次卷积输出特征图的形状和输入不一致，则对输入图片做1x1卷积，将其输出形状调整为一致class BottleneckBlock(nn.Layer):
    def __init__(self,
                 num_channels,
                 num_filters,
                 stride=1,
                 shortcut=True,
                 version='O'
                 ):
        super(BottleneckBlock,self).__init__()
        pathA_dict={}
        pathB_dict={}
        pathA_default=nn.Sequential(
            ConvBNLayer(num_channels=num_channels,num_filters=num_filters,filter_size=1,stride=stride,),
            ConvBNLayer(num_channels=num_filters,num_filters=num_filters,filter_size=3,),
            ConvBNLayer(num_channels=num_filters,num_filters=num_filters*4,filter_size=1,act='None'),
        )
        pathB_default=nn.Sequential(
            ConvBNLayer(num_channels=num_channels,num_filters=num_filters*4,filter_size=1,stride=stride,act='None'),
        )
        self.shortcut=shortcut
        self.pathA=pathA_dict.get(version,pathA_default)
        self.pathB=pathB_dict.get(version,pathB_default)
        self._num_channels_out=num_filters*4
    def forward(self,inputs):
        pathA=self.pathA(inputs)        if self.shortcut:
            pathB=inputs        else:
            pathB=self.pathB(inputs)
        output=paddle.add(x=pathA,y=pathB)
        output=nn.functional.relu(output)        return output

# 定义ResNet模型class ResNet(nn.Layer):
    def __init__(self,layers=50,class_dim=10,version='O'):
        """
        layers,网络层数，可以可选项：50,101,152
        class_dim,分类标签的类别数
        """
        super(ResNet,self).__init__()
        self.version=version
        self.layers=layers
        self.max_accuracy=0.0
        
        supported_layers=[50,101,152]        assert layers in supported_layers,\        "supported layers are {} but input layer is {}".format(supported_layers,layers)        # ResNet50包含的stage1-4模块分别包括3,4,6,3个残差块
        if layers==50:
            depth=[3,4,6,3]        # ResNet101包含的stage1-4模块分别包括3,4,23,3个残差块
        if layers==101:
            depth=[3,4,23,3]        # ResNet152包含的stage1-4分别包括3,8,36,3个残差块
        if layers==152:
            depth=[3,8,36,3]        # stage1-4所使用残差块的输出通道数
        num_filters=[64,128,256,512]        # input stem模块,默认版本：64个7x7的卷积加上一个3x3最大化池化层，步长均为2
        input_stem_dict={}
        input_stem_default=nn.Sequential(
            ConvBNLayer(num_channels=3,num_filters=64,filter_size=7,stride=2,),
            nn.MaxPool2D(kernel_size=3,stride=2,padding=1,),
        )
        self.input_stem=input_stem_dict.get(version,input_stem_default)        # stage1-4模块，使用各个残差块进行卷积操作
        self.bottleneck_block_list=[]
        num_channels=64
        for block in range(len(depth)):
            shortcut=False
            for i in range(depth[block]):
                bottleneck_block=self.add_sublayer(                    'bb_%d_%d'%(block,i),
                    BottleneckBlock(
                        num_channels=num_channels,
                        num_filters=num_filters[block],
                        stride=2 if i==0 and block!=0 else 1,
                        shortcut=shortcut,
                        version=version))
                num_channels=bottleneck_block._num_channels_out
                self.bottleneck_block_list.append(bottleneck_block)
                shortcut=True

        # 在stage4的输出特征图上使用全局池化
        self.pool2d_avg=nn.AdaptiveAvgPool2D(output_size=1)        
        # stdv用来作为全连接层随机初始化参数的方差
        import math
        stdv=1.0/math.sqrt(2048*1.0)        # 创建全连接层，输出大小为类别数目，经过残差网络的卷积核全局池化后，
        # 卷积特征的维度是[B,2048,1,1]，故最后一层全连接层的输入维度是2048
        self.out=nn.Linear(in_features=2048,out_features=class_dim,
        weight_attr=paddle.ParamAttr(
            initializer=paddle.nn.initializer.Uniform(-stdv,stdv)))    
    def forward(self,inputs):
        x=self.input_stem(inputs)        for bottleneck_block in self.bottleneck_block_list:
            x=bottleneck_block(x)
        x=self.pool2d_avg(x)
        x=paddle.reshape(x,[x.shape[0],-1])
        x=self.out(x)        return x

# pathA_tweak=nn.Sequential(#             ConvBNLayer(num_channels=num_channels,num_filters=num_filters,filter_size=1,),#             ConvBNLayer(num_channels=num_filters,num_filters=num_filters,filter_size=3,stride=stride,),#             ConvBNLayer(num_channels=num_filters,num_filters=num_filters*4,filter_size=1,),#         )# pathA_dict['B']=pathA_tweak

# input_stem_tweak=nn.Sequential(#             ConvBNLayer(num_channels=3,num_filters=64,filter_size=3,stride=2,)#             ConvBNLayer(num_channels=64,num_filters=64,filter_size=3,)#             ConvBNLayer(num_channels=64,num_filters=64,filter_size=3,)#             nn.MaxPool2D(kernel_size=3,stride=2,padding=1,)#         )# input_stem_dict['C']=input_stem_tweak

# pathB_tweak=nn.Sequential(#     nn.AvgPool2D(kernel_size=stride,stride=stride),#     ConvBNLayer(num_channels=num_channels,num_filters=num_filters*4,filter_size=1),# )# pathB_dict['D']=pathB_tweak# pathA_dict['D']=pathA_tweak

# 定义残差块# 每个残差块会对输入图片做三次卷积，然后跟输入图片进行短接# 如果残差块中第三次卷积输出特征图的形状和输入不一致，则对输入图片做1x1卷积，将其输出形状调整为一致class BottleneckBlock(nn.Layer):
    def __init__(self,
                 num_channels,
                 num_filters,
                 stride=1,
                 shortcut=True,
                 version='O'
                 ):
        super(BottleneckBlock,self).__init__()
        pathA_dict={}
        pathB_dict={}        # default版本
        pathA_default=nn.Sequential(
            ConvBNLayer(num_channels=num_channels,num_filters=num_filters,filter_size=1,stride=stride,),
            ConvBNLayer(num_channels=num_filters,num_filters=num_filters,filter_size=3,),
            ConvBNLayer(num_channels=num_filters,num_filters=num_filters*4,filter_size=1,act='None'),
        )
        pathB_default=nn.Sequential(
            ConvBNLayer(num_channels=num_channels,num_filters=num_filters*4,filter_size=1,stride=stride,act='None'),
        )        # B版本修改
        pathA_tweak=nn.Sequential(
            ConvBNLayer(num_channels=num_channels,num_filters=num_filters,filter_size=1,),
            ConvBNLayer(num_channels=num_filters,num_filters=num_filters,filter_size=3,stride=stride,),
            ConvBNLayer(num_channels=num_filters,num_filters=num_filters*4,filter_size=1,),
        )
        pathA_dict['B']=pathA_tweak        # D 版本修改
        pathB_tweak=nn.Sequential(
            nn.AvgPool2D(kernel_size=stride,stride=stride),
            ConvBNLayer(num_channels=num_channels,num_filters=num_filters*4,filter_size=1),
        )
        pathB_dict['D']=pathB_tweak
        pathA_dict['D']=pathA_tweak
        self.shortcut=shortcut
        self.pathA=pathA_dict.get(version,pathA_default)
        self.pathB=pathB_dict.get(version,pathB_default)
        self._num_channels_out=num_filters*4
    def forward(self,inputs):
        pathA=self.pathA(inputs)        if self.shortcut:
            pathB=inputs        else:
            pathB=self.pathB(inputs)
        output=paddle.add(x=pathA,y=pathB)
        output=nn.functional.relu(output)        return output

# 定义ResNet模型class ResNet(nn.Layer):
    def __init__(self,layers=50,class_dim=10,version='O'):
        """
        layers,网络层数，可以可选项：50,101,152
        class_dim,分类标签的类别数
        """
        super(ResNet,self).__init__()
        self.version=version
        self.layers=layers
        self.max_accuracy=0.0
        
        supported_layers=[50,101,152]        assert layers in supported_layers,\        "supported layers are {} but input layer is {}".format(supported_layers,layers)        # ResNet50包含的stage1-4模块分别包括3,4,6,3个残差块
        if layers==50:
            depth=[3,4,6,3]        # ResNet101包含的stage1-4模块分别包括3,4,23,3个残差块
        if layers==101:
            depth=[3,4,23,3]        # ResNet152包含的stage1-4分别包括3,8,36,3个残差块
        if layers==152:
            depth=[3,8,36,3]        # stage1-4所使用残差块的输出通道数
        num_filters=[64,128,256,512]        # input stem模块,default版本：64个7x7的卷积加上一个3x3最大化池化层，步长均为2
        input_stem_dict={}
        input_stem_default=nn.Sequential(
            ConvBNLayer(num_channels=3,num_filters=64,filter_size=7,stride=2,),
            nn.MaxPool2D(kernel_size=3,stride=2,padding=1,),
        )        # C版本修改
        input_stem_tweak=nn.Sequential(
            ConvBNLayer(num_channels=3,num_filters=64,filter_size=3,stride=2,),
            ConvBNLayer(num_channels=64,num_filters=64,filter_size=3,),
            ConvBNLayer(num_channels=64,num_filters=64,filter_size=3,),
            nn.MaxPool2D(kernel_size=3,stride=2,padding=1,),
        )
        input_stem_dict['C']=input_stem_tweak

        self.input_stem=input_stem_dict.get(version,input_stem_default)        # stage1-4模块，使用各个残差块进行卷积操作
        self.bottleneck_block_list=[]
        num_channels=64
        for block in range(len(depth)):
            shortcut=False
            for i in range(depth[block]):
                bottleneck_block=self.add_sublayer(                    'bb_%d_%d'%(block,i),
                    BottleneckBlock(
                        num_channels=num_channels,
                        num_filters=num_filters[block],
                        stride=2 if i==0 and block!=0 else 1,
                        shortcut=shortcut,
                        version=version))
                num_channels=bottleneck_block._num_channels_out
                self.bottleneck_block_list.append(bottleneck_block)
                shortcut=True

        # 在stage4的输出特征图上使用全局池化
        self.pool2d_avg=nn.AdaptiveAvgPool2D(output_size=1)        
        # stdv用来作为全连接层随机初始化参数的方差
        import math
        stdv=1.0/math.sqrt(2048*1.0)        # 创建全连接层，输出大小为类别数目，经过残差网络的卷积核全局池化后，
        # 卷积特征的维度是[B,2048,1,1]，故最后一层全连接层的输入维度是2048
        self.out=nn.Linear(in_features=2048,out_features=class_dim,
        weight_attr=paddle.ParamAttr(
            initializer=paddle.nn.initializer.Uniform(-stdv,stdv)))    
    def forward(self,inputs):
        x=self.input_stem(inputs)        for bottleneck_block in self.bottleneck_block_list:
            x=bottleneck_block(x)
        x=self.pool2d_avg(x)
        x=paddle.reshape(x,[x.shape[0],-1])
        x=self.out(x)        return x

import paddleimport paddle.nn as nnimport osimport cv2import numpy as npimport openpyxl

if not os.path.isdir("train_data"):
    os.mkdir("train_data")else:    print('Train_data exist')if not os.path.isdir('PALM-Training400'):
    !unzip -oq /home/aistudio/data/data19469/training.zip
    !unzip -oq /home/aistudio/data/data19469/validation.zip
    !unzip -oq /home/aistudio/data/data19469/valid_gt.zip
    !unzip -oq /home/aistudio/PALM-Training400/PALM-Training400.zip -d /home/aistudio/train_data/else:    print('The data has been decompressed')

# 查看训练集! dir /home/aistudio/train_data/PALM-Training400/.

def transform_img(img):
    # 将图片尺寸缩放到 224x224
    img=cv2.resize(img,(224,224))    # 读入的图像数据格式是[H,W,C]
    # 使用转置操作将其变成[C,H,W]
    img=np.transpose(img,(2,0,1))
    img.astype('float32')
    img=img/255.0
    img=img*2.0-1.0
    return img

def data_loader(datadir,batch_size=10,mode='train'):
    filenames=os.listdir(datadir)    def reader():
        if mode =='train':
            np.random.shuffle(filenames)
        batch_imgs=[]
        batch_labels=[]        for name in filenames:
            filepath=os.path.join(datadir,name)
            img=cv2.imread(filepath)
            img=transform_img(img)            if name[0]=='H' or name[0]=='N':
                label=0
            elif name[0]=='P':
                label=1
            elif name[0]=='V':                continue
            else:                raise('Not excepted file name')
            batch_imgs.append(img)
            batch_labels.append(label)            if len(batch_imgs)==batch_size:
                imgs_array=np.array(batch_imgs).astype('float32')
                labels_array=np.array(batch_labels).astype('float32').reshape(-1,1)                yield imgs_array,labels_array
                batch_imgs=[]
                batch_labels=[]        if len(batch_imgs)>0:
            imgs_array=np.array(batch_imgs).astype('float32')
            labels_array=np.array(batch_labels).astype('float32').reshape(-1,1)            yield imgs_array,labels_array    return reader    
def valid_data_loader(datadir,annotiondir):
    labeldir=annotiondir    def reader(batch_size=50):
        images=[]
        labels=[]
        workbook=openpyxl.load_workbook(labeldir,data_only=True)
        worksheet=workbook.active        for row in worksheet.iter_rows(min_row=2,max_row=worksheet.max_row):
            image=cv2.imread(datadir+'/'+row[1].value)
            image=transform_img(image)
            images.append(image)
            label=float(row[2].value)
            labels.append(label)            if len(images)==batch_size:
                images_array=np.array(images).astype('float32')
                labels_array=np.array(labels).astype('float32').reshape(-1,1)                yield images_array,labels_array
                images=[]
                labels=[]        if len(images)>0:
            images_array=np.array(images).astype('float32')
            labels_array=np.array(labels).astype('float32').reshape(-1,1)            yield images_array,labels_array    return reader

# 构建模型保存函数def save(accuracy,model):
    print('model save success !')    if model==None:        return
    model.max_accuracy=accuracy # 覆盖当前的最大正确率
    paddle.save(model.state_dict(),f'./model/resnet{model.layers}_v{model.version}_PALM.pdparams') # 保存模型save(1.0,None)

def train_pm(model,
             datadir,
             annotiondir,
             optimizer,
             batch_size=10,
             EPOCH_NUM=20,
             use_gpu=False,
             save=None):
    # 使用0号GPU训练
    paddle.set_device('gpu:0') if use_gpu else paddle.set_device('cpu')    print('********start training********')    # 定义训练数据读取器train_loader和验证数据读取器valid_loader
    train_loader=data_loader(datadir=datadir+'/train_data/PALM-Training400',batch_size=batch_size,mode='train')
    valid_loader=valid_data_loader(datadir+'/PALM-Validation400',annotiondir)    # 初始化模型对应参数的验证正确率
    model.max_accuracy,_=valid_pm(model,valid_loader,batch_size=50)    print('Initial max accuracy ：',model.max_accuracy)    
    for epoch in range(EPOCH_NUM):
        model.train()        for batch_id,data in enumerate(train_loader()):
            x_data,y_data=data
            img=paddle.to_tensor(x_data)
            label=paddle.to_tensor(y_data).astype('int64')            # 使用模型进行前向计算，得到预测值
            out=model(img)            # 计算相应的损失值，并且得到对应的平均损失
            loss=nn.functional.cross_entropy(out,label,reduction='none')
            avg_loss=paddle.mean(loss)            if batch_id%10==0: #每10个batch输出1次训练结果
                print("epoch:{}===batch_id:{}===loss:{:.4f}".format(
                    epoch,batch_id,float(avg_loss.numpy())))            # 反向传播，更新权重，消除梯度
            optimizer.clear_grad()
            loss.backward()
            optimizer.step()        
        # 每个epoch进行一次训练集的验证，获取模型在验证集上的正确率和损失值
        valid_accuracy,valid_loss=valid_pm(model,valid_loader,batch_size=50)        print('[validation]:======accuracy:{:.5f}/loss:{:.5f}'.format(valid_accuracy,valid_loss))        
        # 如果模型准确率上升并且存在一个模型保存的策略，那么保存模型
        if save!=None and valid_accuracy>model.max_accuracy:
            save(valid_accuracy,model)            print('max accuracy :',model.max_accuracy)        print()    print('Final max accuracy :',model.max_accuracy)

def valid_pm(model,valid_loader,batch_size=100):
    model.eval()    print("*****valid data import success*****")
    batch_accuracy=[]
    batch_loss=[]    for batch_id,data in enumerate(valid_loader(batch_size=batch_size)):        # 加载数据，并且进行类型转换
        x_data,y_data=data
        img=paddle.to_tensor(x_data)
        label=paddle.to_tensor(y_data).astype('int64')        # 前向计算，计算预测值
        out=model(img)
        predict=paddle.argmax(out,1)        # 计算损失值和准确率，并且加入到相应列表中
        loss=nn.functional.cross_entropy(out,label,reduction='none')
        avg_loss=paddle.mean(loss)
        accuracy=sum(predict.numpy().reshape(-1,1)==label.numpy())/float(label.shape[0])
        batch_loss.append(float(avg_loss.numpy()))
        batch_accuracy.append(accuracy)    
    # 将所有批次的损失值和准确率平均，得到最终损失值和准确率    
    avg_loss=np.mean(batch_loss)
    avg_accuracy=np.mean(batch_accuracy)    return avg_accuracy,avg_loss

# 超参数的设置use_gpu=Truelr=0.0001momentum=0.9load_model=Truesave_model=FalseEPOCH_NUM=20

# 版本参数的设置model_version='O'filedir=os.getcwd() #获取文件当前的主路径model=ResNet(layers=50,class_dim=2,version=model_version)if os.path.exists(f'./model/resnet{model.layers}_v{model.version}_PALM.pdparams') and load_model:
    model_params=paddle.load(f'./model/resnet{model.layers}_v{model_version}_PALM.pdparams')
    model.set_state_dict(model_params) # 加载预训练模型参数annotion_path=filedir+'/PALM-Validation-GT/PM_Label_and_Fovea_Location.xlsx' # 获取验证集标签数据地址optimizer=paddle.optimizer.Momentum(learning_rate=lr,momentum=momentum,parameters=model.parameters())# 选择优化器print('文件主路径：',filedir)print('训练模型版本：',model_version)print('是否采用预训练模型：',load_model)print('是否采用GPU：',use_gpu)if save_model: # 判断是否需要保存模型参数
    save=saveelse:
    save=Nonetrain_pm(model,filedir,annotion_path,optimizer,EPOCH_NUM=EPOCH_NUM,use_gpu=use_gpu,save=save)

# 版本参数的设置model_version='B'filedir=os.getcwd() #获取文件当前的主路径model=ResNet(layers=50,class_dim=2,version=model_version)if os.path.exists(f'./model/resnet{model.layers}_v{model.version}_PALM.pdparams') and load_model:
    model_params=paddle.load(f'./model/resnet{model.layers}_v{model_version}_PALM.pdparams')
    model.set_state_dict(model_params) # 加载预训练模型参数annotion_path=filedir+'/PALM-Validation-GT/PM_Label_and_Fovea_Location.xlsx' # 获取验证集标签数据地址optimizer=paddle.optimizer.Momentum(learning_rate=lr,momentum=momentum,parameters=model.parameters())# 选择优化器print('文件主路径：',filedir)print('训练模型版本：',model_version)print('是否采用预训练模型：',load_model)print('是否采用GPU：',use_gpu)if save_model: # 判断是否需要保存模型参数
    save=saveelse:
    save=Nonetrain_pm(model,filedir,annotion_path,optimizer,EPOCH_NUM=EPOCH_NUM,use_gpu=use_gpu,save=save)

# 版本参数的设置model_version='C'filedir=os.getcwd() #获取文件当前的主路径model=ResNet(layers=50,class_dim=2,version=model_version)if os.path.exists(f'./model/resnet{model.layers}_v{model.version}_PALM.pdparams') and load_model:
    model_params=paddle.load(f'./model/resnet{model.layers}_v{model_version}_PALM.pdparams')
    model.set_state_dict(model_params) # 加载预训练模型参数annotion_path=filedir+'/PALM-Validation-GT/PM_Label_and_Fovea_Location.xlsx' # 获取验证集标签数据地址optimizer=paddle.optimizer.Momentum(learning_rate=lr,momentum=momentum,parameters=model.parameters())# 选择优化器print('文件主路径：',filedir)print('训练模型版本：',model_version)print('是否采用预训练模型：',load_model)print('是否采用GPU：',use_gpu)if save_model: # 判断是否需要保存模型参数
    save=saveelse:
    save=Nonetrain_pm(model,filedir,annotion_path,optimizer,EPOCH_NUM=EPOCH_NUM,use_gpu=use_gpu,save=save)

# 版本参数的设置model_version='D'filedir=os.getcwd() #获取文件当前的主路径model=ResNet(layers=50,class_dim=2,version=model_version)if os.path.exists(f'./model/resnet{model.layers}_v{model.version}_PALM.pdparams') and load_model:
    model_params=paddle.load(f'./model/resnet{model.layers}_v{model_version}_PALM.pdparams')
    model.set_state_dict(model_params) # 加载预训练模型参数annotion_path=filedir+'/PALM-Validation-GT/PM_Label_and_Fovea_Location.xlsx' # 获取验证集标签数据地址optimizer=paddle.optimizer.Momentum(learning_rate=lr,momentum=momentum,parameters=model.parameters())# 选择优化器print('文件主路径：',filedir)print('训练模型版本：',model_version)print('是否采用预训练模型：',load_model)print('是否采用GPU：',use_gpu)if save_model: # 判断是否需要保存模型参数
    save=saveelse:
    save=Nonetrain_pm(model,filedir,annotion_path,optimizer,EPOCH_NUM=EPOCH_NUM,use_gpu=use_gpu,save=save)

annotion_path='./PALM-Validation-GT/PM_Label_and_Fovea_Location.xlsx'valid_loader=valid_data_loader('./PALM-Validation400',annotion_path)

# 模型版本选择model_version='O'model_layers=50# 模型的载入、模型参数的载入和配置model=ResNet(layers=model_layers,class_dim=2,version=model_version)
model_params=paddle.load(f'./model/resnet{model.layers}_v{model.version}_PALM.pdparams')
model.set_state_dict(model_params)# 模型的验证过程valid_accuracy,valid_loss=valid_pm(model,valid_loader,batch_size=50)print('[validation]:===model:ResNet{}-{}===accuracy:{:.5f}/loss:{:.5f}'.format(model.layers,model.version,valid_accuracy,valid_loss))

# 模型版本选择model_version='B'model_layers=50# 模型的载入、模型参数的载入和配置model=ResNet(layers=model_layers,class_dim=2,version=model_version)
model_params=paddle.load(f'./model/resnet{model.layers}_v{model.version}_PALM.pdparams')
model.set_state_dict(model_params)# 模型的验证过程valid_accuracy,valid_loss=valid_pm(model,valid_loader,batch_size=50)print('[validation]:===model:ResNet{}-{}===accuracy:{:.5f}/loss:{:.5f}'.format(model.layers,model.version,valid_accuracy,valid_loss))

# 模型版本选择model_version='C'model_layers=50# 模型的载入、模型参数的载入和配置model=ResNet(layers=model_layers,class_dim=2,version=model_version)
model_params=paddle.load(f'./model/resnet{model.layers}_v{model.version}_PALM.pdparams')
model.set_state_dict(model_params)# 模型的验证过程valid_accuracy,valid_loss=valid_pm(model,valid_loader,batch_size=50)print('[validation]:===model:ResNet{}-{}===accuracy:{:.5f}/loss:{:.5f}'.format(model.layers,model.version,valid_accuracy,valid_loss))

# 模型版本选择model_version='D'model_layers=50# 模型的载入、模型参数的载入和配置model=ResNet(layers=model_layers,class_dim=2,version=model_version)
model_params=paddle.load(f'./model/resnet{model.layers}_v{model.version}_PALM.pdparams')
model.set_state_dict(model_params)# 模型的验证过程valid_accuracy,valid_loss=valid_pm(model,valid_loader,batch_size=50)print('[validation]:===model:ResNet{}-{}===accuracy:{:.5f}/loss:{:.5f}'.format(model.layers,model.version,valid_accuracy,valid_loss))