第十一届 “中国软件杯”百度遥感赛项：变化检测功能
比赛介绍
“中国软件杯”大学生软件设计大赛是一项面向中国在校学生的公益性赛事，是2021年全国普通高校大学生竞赛榜单内竞赛。大赛由国家工业和信息化部、教育部、江苏省人民政府共同主办，致力于正确引导我国在校学生积极参加软件科研活动，切实增强自我创新能力和实际动手能力，为我国软件和信息技术服务业培养出更多高端、优秀的人才。2022年，百度飞桨承办了A组和B组两个赛道，本赛题为A组。

比赛官网链接

赛题背景
掌握国土资源利用和土地覆盖类型，是地理国情普查与监测的重要内容。高效获取准确、客观的土地利用情况，监测国土变化情况，可以为国家和地方提供地理国情信息决策支撑。随着遥感、传感器技术的发展，特别是多时相高分辨率遥感图像数据的普及，使我们可以足不出户，就能掌握全球任一地表的细微变化。

目前，我国遥感领域已步入了高分辨率影像的快车道，对遥感数据的分析应用服务的需求也与日俱增。传统方式对高分辨率卫星遥感图像的对特征刻画能力差且依赖人工经验工作量巨大。随着人工智能技术的兴起，特别是基于深度学习的图像识别方法获得了极大的发展，相关技术也推动了遥感领域的变革。相对于传统基于人海战术的目视解译方法，基于深度学习的遥感图像识别技术可以自动分析图像中的地物类型，在准确率和效率方面展现出极大的潜力。

此次赛题由百度飞桨和北航LEVIR团队 共同设置，要求选手使用百度AI Studio平台进行训练，基于国产化人工智能框架——百度飞桨PaddlePaddle框架进行开发，设计并开发一个可以通过深度学习技术实现对遥感图像自动解译的WEB系统。

任务说明
变化检测部分要求参赛者利用提供的训练数据，实现对多时相图像中的建筑变化检测。具体而言，多时相遥感图像建筑物变化检测任务是给定两张不同时间拍摄的相同位置（地理配准）的遥感图像，要求定位出其中建筑变化的区域。

参考链接：什么是遥感影像变化检测？

数据集介绍
参见数据集链接和赛题说明。

项目简介
本项目在官方baseline上进行修改，由于本人初次接触有关遥感图像的处理，所能作的工作也无非是调参，更改学习率优化器策略之类，参数也并非最优，大家可以多多优化。
本项目由于手动扩充了数据集，使用V100 32G环境训练时间约48小时，时间很长，推理时间为6分钟左右，最后进行了一些后处理，分数大概在0.877左右
项目方案
本项目学习率选择了4e-4，CROP_SIZE为336（感觉可以试试512），训练集数据占比为0.8，这里也可以优化。
本项目数据增强部分参考了iFLYTEK：高分辨率遥感影像耕地地块提取挑战赛，手动将数据集扩展了10倍（这也是训练时间很长的原因），使用了随机裁剪，去雾（可能是负优化，大家可以删掉试试），随机模糊，随机交换，随机翻转。
本项目在BIT模型上未做过多改动，backbone选择Resnet34，token_len改为6。
本项目学习率策略选用了OneCycleLR，优化器选择了AdamW，权重衰减为0.001，由于paddle并没有内置的OneCycleLR策略，所以参考了paddlepaddle 23 paddle内置的12种学习率调度器+OneCycleLR的调度曲线中的代码，损失函数选择了CE+Dice（1：1），这边也可以继续优化。 5.后处理策略为删去了检测出的面积小于200的建筑物（大部分应该都是噪声），同时去掉了建筑物内部面积小于1600的孔洞。
数据预处理
In [1]

解压数据集

该操作涉及大量文件IO，可能需要一些时间

!unzip -o -d /home/aistudio/data/data134796/dataset /home/aistudio/data/data134796/train_data.zip > /dev/null
!unzip -o -d /home/aistudio/data/data134796/dataset /home/aistudio/data/data134796/test_data.zip > /dev/null
In [2]

划分训练集/验证集，并生成文件名列表

import random
import os.path as osp
from glob import glob

随机数生成器种子

RNG_SEED = 114514

调节此参数控制训练集数据的占比

TRAIN_RATIO = 0.80

数据集路径

DATA_DIR = ‘/home/aistudio/data/data134796/dataset/’

def write_rel_paths(phase, names, out_dir, prefix=‘’):
“”“将文件相对路径存储在txt格式文件中”“”
with open(osp.join(out_dir, phase+‘.txt’), ‘w’) as f:
for name in names:
f.write(
’ ‘.join([
osp.join(prefix, ‘A’, name),
osp.join(prefix, ‘B’, name),
osp.join(prefix, ‘label’, name)
])
)
f.write(’\n’)

random.seed(RNG_SEED)

随机划分训练集/验证集

names = list(map(osp.basename, glob(osp.join(DATA_DIR, ‘train’, ‘label’, ‘*.png’))))

对文件名进行排序，以确保多次运行结果一致

names.sort()
random.shuffle(names)
len_train = int(len(names)*TRAIN_RATIO) # 向下取整
write_rel_paths(‘train’, names[:len_train], DATA_DIR, prefix=‘train’)
write_rel_paths(‘val’, names[len_train:], DATA_DIR, prefix=‘train’)

处理测试集

test_names = map(osp.basename, glob(osp.join(DATA_DIR, ‘test’, ‘A’, ‘*.png’)))
test_names = sorted(test_names)
write_rel_paths(
‘test’,
test_names,
DATA_DIR,
prefix=‘test’
)

print(“数据集划分已完成。”)
数据集划分已完成。
模型训练与推理
本项目使用PaddleRS套件搭建模型训练与推理框架。PaddleRS是基于飞桨开发的遥感处理平台，支持遥感图像分类、目标检测、图像分割、以及变化检测等常用遥感任务，能够帮助开发者更便捷地完成从训练到部署全流程遥感深度学习应用。在变化检测方面，PaddleRS目前支持9个state-of-the-art（SOTA）模型，且复杂的训练和推理过程被封装到数个API中，能够提供开箱即用的用户体验。

In [ ]

安装第三方库

!pip install scikit-image > /dev/null
!pip install matplotlib==3.4 > /dev/null

安装PaddleRS（AI Studio上缓存的版本）

!unzip -o -d /home/aistudio/ /home/aistudio/data/data135375/PaddleRS-develop.zip > /dev/null
!mv /home/aistudio/PaddleRS-develop /home/aistudio/PaddleRS
!pip install -e /home/aistudio/PaddleRS > /dev/null

因为sys.path可能没有及时更新，这里选择手动更新

import sys
sys.path.append(‘/home/aistudio/PaddleRS’)
In [2]

导入一些需要用到的库

import random
import os
import os.path as osp
from copy import deepcopy
from functools import partial
import math
import paddlers.models.ppseg as ppseg
from paddle.optimizer import lr
import numpy as np
import skimage
import cv2
import paddle
import paddlers as pdrs
from paddlers import transforms as T
from skimage.io import imread, imsave
from PIL import Image,ImageEnhance
from tqdm import tqdm
from matplotlib import pyplot as plt
/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/tensor/creation.py:130: DeprecationWarning: np.object is a deprecated alias for the builtin object. To silence this warning, use object by itself. Doing this will not modify any behavior and is safe.
Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations
if data.dtype == np.object:
[05-23 19:18:26 MainThread @utils.py:79] WRN paddlepaddle version: 2.2.2. The dynamic graph version of PARL is under development, not fully tested and supported
In [3]

定义全局变量

可在此处调整实验所用超参数

随机种子

SEED = 1919810

数据集路径

DATA_DIR = ‘/home/aistudio/data/data134796/dataset/’

实验路径。实验目录下保存输出的模型权重和结果

EXP_DIR = ‘/home/aistudio/exp/’

保存最佳模型的路径

BEST_CKP_PATH = osp.join(EXP_DIR, ‘best_model’, ‘model.pdparams’)

训练的epoch数

NUM_EPOCHS = 150

每多少个epoch保存一次模型权重参数

SAVE_INTERVAL_EPOCHS = 5

初始学习率

LR = 4e-4

学习率衰减步长（注意，单位为迭代次数而非epoch数），即每多少次迭代将学习率衰减一半

DECAY_STEP = 1000

训练阶段 batch size

TRAIN_BATCH_SIZE = 32

推理阶段 batch size

INFER_BATCH_SIZE = 32

加载数据所使用的进程数

NUM_WORKERS = 4

裁块大小

CROP_SIZE = 336

模型推理阶段使用的滑窗步长

STRIDE = 64

影像原始大小

ORIGINAL_SIZE = (1024, 1024)
In [4]

固定随机种子，尽可能使实验结果可复现

random.seed(SEED)
np.random.seed(SEED)
paddle.seed(SEED)
<paddle.fluid.core_avx.Generator at 0x7f35f0723eb0>
In [5]

定义一些辅助函数

def info(msg, **kwargs):
print(msg, **kwargs)

def warn(msg, **kwargs):
print(‘\033[0;31m’+msg, **kwargs)

def quantize(arr):
return (arr*255).astype(‘uint8’)
模型构建
作为演示，本项目选用LEVIR小组2021年的作品——基于Transformer的变化检测模型BIT-CD[1]。原论文请参考此链接，原作者官方实现请参考此链接。

[1] Hao Chen, Zipeng Qi, and Zhenwei Shi. Remote Sensing Image Change Detection with Transformers. IEEE Transactions on Geoscience and Remote Sensing.

In [6]

调用PaddleRS API一键构建模型

model = pdrs.tasks.BIT(
# 模型输出类别数
num_classes=2,
# 是否使用混合损失函数，默认使用交叉熵损失函数训练
use_mixed_loss=False,
# 模型输入通道数
in_channels=3,
# 模型使用的骨干网络，支持’resnet18’或’resnet34’
backbone=‘resnet34’,
# 骨干网络中的resnet stage数量
n_stages=4,
# 是否使用tokenizer获取语义token
use_tokenizer=True,
# token的长度
token_len=6,
# 若不使用tokenizer，则使用池化方式获取token。此参数设置池化模式，有’max’和’avg’两种选项，分别对应最大池化与平均池化
pool_mode=‘max’,
# 池化操作输出特征图的宽和高（池化方式得到的token的长度为pool_size的平方）
pool_size=2,
# 是否在Transformer编码器中加入位置编码（positional embedding）
enc_with_pos=True,
# Transformer编码器使用的注意力模块（attention block）个数
enc_depth=1,
# Transformer编码器中每个注意力头的嵌入维度（embedding dimension）
enc_head_dim=64,
# Transformer解码器使用的注意力模块个数
dec_depth=8,
# Transformer解码器中每个注意力头的嵌入维度
dec_head_dim=8
)
W0523 19:18:38.167052 11932 device_context.cc:447] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 11.2, Runtime API Version: 10.1
W0523 19:18:38.172040 11932 device_context.cc:465] device: 0, cuDNN Version: 7.6.
数据集构建
首先，参考iFLYTEK：高分辨率遥感影像耕地地块提取挑战赛，进行了数据集的扩增，对训练集进行了色度、对比度、亮度以及清晰度的扩增，使用扩增后的数据集进行训练，然乎使用了paddlers自带的优化策略：随机裁剪，去雾（可能是负优化，大家可以删掉试试），随机模糊，随机交换，随机翻转。

In [10]

手动扩充数据集

Image.MAX_IMAGE_PIXELS = None

color_aug=[0.1,0.2,0.3]
bright_aug=[0.5,2.0]
contrast_aug=[0.5,2.0]
sharp_aug=[0.0,0.5,2.0]

def enhance(line,fr,fw):
fw.write(line)
data_directory = ‘/home/aistudio/data/data134796/dataset/’
img_path1 = osp.join(data_directory,line.strip().split(’ ‘)[0])
img_path2 = osp.join(data_directory,line.strip().split(’ ‘)[1])
ann_path = osp.join(data_directory,line.strip().split(’ ‘)[2])
img1 = Image.open(img_path1)
img2 = Image.open(img_path2)
for i,rate in enumerate(color_aug):
aug_img1 = ImageEnhance.Color(img1).enhance(rate)
aug_img2 = ImageEnhance.Color(img2).enhance(rate)
aug_img1.save(img_path1.split(’.‘)[0]+’_c{}.png’.format(i+1))
aug_img2.save(img_path2.split(‘.’)[0]+‘_c{}.png’.format(i+1))
fw.write(img_path1.split(‘.’)[0]+‘_c{}.png’.format(i+1)+ ’ ’ +img_path2.split(‘.’)[0]+‘_c{}.png’.format(i+1)+ ’ ‘+ ann_path+’\n’)
for i,rate in enumerate(bright_aug):
aug_img1 = ImageEnhance.Brightness(img1).enhance(rate)
aug_img2 = ImageEnhance.Brightness(img2).enhance(rate)
aug_img1.save(img_path1.split(‘.’)[0]+‘_b{}.png’.format(i+1))
aug_img2.save(img_path2.split(‘.’)[0]+‘_b{}.png’.format(i+1))
fw.write(img_path1.split(‘.’)[0]+‘_b{}.png’.format(i+1)+ ’ ’ +img_path2.split(‘.’)[0]+‘_b{}.png’.format(i+1)+ ’ ‘+ ann_path+’\n’)
for i,rate in enumerate(contrast_aug):
aug_img1 = ImageEnhance.Contrast(img1).enhance(rate)
aug_img2 = ImageEnhance.Contrast(img2).enhance(rate)
aug_img1.save(img_path1.split(‘.’)[0]+‘_ct{}.png’.format(i+1))
aug_img2.save(img_path2.split(‘.’)[0]+‘_ct{}.png’.format(i+1))
fw.write(img_path1.split(‘.’)[0]+‘_ct{}.png’.format(i+1)+ ’ ’ +img_path2.split(‘.’)[0]+‘_ct{}.png’.format(i+1)+ ’ ‘+ ann_path+’\n’)
for i,rate in enumerate(sharp_aug):
aug_img1 = ImageEnhance.Sharpness(img1).enhance(rate)
aug_img2 = ImageEnhance.Sharpness(img2).enhance(rate)
aug_img1.save(img_path1.split(‘.’)[0]+‘_s{}.png’.format(i+1))
aug_img2.save(img_path2.split(‘.’)[0]+‘_s{}.png’.format(i+1))
fw.write(img_path1.split(‘.’)[0]+‘_s{}.png’.format(i+1)+ ’ ’ +img_path2.split(‘.’)[0]+‘_s{}.png’.format(i+1)+ ’ ‘+ ann_path+’\n’)

with open(‘/home/aistudio/data/data134796/dataset/train.txt’,‘r’,encoding=‘utf-8’) as fr:
with open(‘/home/aistudio/data/data134796/dataset/enhance_train.txt’,‘w’,encoding=‘utf-8’) as fw:
lines = fr.readlines()
for line in lines:
enhance(line,fr,fw)

with open(‘/home/aistudio/data/data134796/dataset/val.txt’,‘r’,encoding=‘utf-8’) as fr:
with open(‘/home/aistudio/data/data134796/dataset/enhance_val.txt’,‘w’,encoding=‘utf-8’) as fw:
lines = fr.readlines()
for line in lines:
enhance(line,fr,fw)
In [ ]

构建需要使用的数据变换（数据增强、预处理）

使用Compose组合多种变换方式。Compose中包含的变换将按顺序串行执行

train_transforms = T.Compose([
#去雾（应该可以删掉）
T.Defogging(),
#随机模糊
T.RandomBlur(prob=0.5),
#随机交换
T.RandomSwap(),
# 随机裁剪
T.RandomCrop(
# 裁剪区域将被缩放到此大小
crop_size=CROP_SIZE,
# 将裁剪区域的横纵比固定为1
aspect_ratio=[1.0, 1.0],
# 裁剪区域相对原始影像长宽比例在一定范围内变动，最小不低于原始长宽的1/5
scaling=[0.2, 1.0]
),
# 以50%的概率实施随机水平翻转
T.RandomHorizontalFlip(prob=0.5),
# 以50%的概率实施随机垂直翻转
T.RandomVerticalFlip(prob=0.5),
# 数据归一化到[-1,1]
T.Normalize(
mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5]
)
])
eval_transforms = T.Compose([
# 在验证阶段，输入原始尺寸影像，对输入影像仅进行归一化处理
# 验证阶段与训练阶段的数据归一化方式必须相同
T.Normalize(
mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5]
)
])

实例化数据集

train_dataset = pdrs.datasets.CDDataset(
data_dir=DATA_DIR,
file_list=osp.join(DATA_DIR, ‘enhance_train.txt’),
label_list=None,
transforms=train_transforms,
num_workers=NUM_WORKERS,
shuffle=True,
binarize_labels=True
)
eval_dataset = pdrs.datasets.CDDataset(
data_dir=DATA_DIR,
file_list=osp.join(DATA_DIR, ‘enhance_val.txt’),
label_list=None,
transforms=eval_transforms,
num_workers=0,
shuffle=False,
binarize_labels=True
)
In [9]

若实验目录不存在，则新建之（递归创建目录）

if not osp.exists(EXP_DIR):
os.makedirs(EXP_DIR)
学习率以及优化器策略
学习率策略选用了OneCycleLR，优化器选择了AdamW，权重衰减为0.001，由于paddle并没有内置的OneCycleLR策略，所以参考了paddlepaddle 23 paddle内置的12种学习率调度器+OneCycleLR的调度曲线中的代码，损失函数选择了CE+Dice（1：1），这边也可以继续优化。

In [11]
class OneCycleLR(lr.LRScheduler):
def init(self,
learning_rate,
total_steps=None,
pct_start=0.3,
last_epoch=- 1,
verbose=False):

    self.total_steps = total_steps
    self.step_size_up = float(pct_start * self.total_steps) - 1
    self.step_size_down = float(self.total_steps - self.step_size_up) - 1
    self.last_epoch = last_epoch

    self.learning_rate = learning_rate
    super(OneCycleLR, self).__init__(learning_rate, last_epoch, verbose)

def _annealing_cos(self, start, end, pct):
    "Cosine anneal from `start` to `end` as pct goes from 0.0 to 1.0."
    cos_out = math.cos(math.pi * pct) + 1
    return end + (start - end) / 2.0 * cos_out

def get_lr(self):
    self.step_num=self.last_epoch 
    down_step_num = self.step_num - self.step_size_up

    a = self._annealing_cos(self.learning_rate * 0.00001, self.learning_rate, self.step_num / self.step_size_up)
    b = self._annealing_cos(self.learning_rate, self.learning_rate * 0.00001, down_step_num / self.step_size_down)

    if self.step_num < self.step_size_up:
        lr_value = a
    else:
        lr_value = b
    return lr_value

In [12]

构建学习率调度器和优化器

lr = OneCycleLR(LR, total_steps=28500, verbose=False)
optimizer = paddle.optimizer.AdamW(lr, parameters=model.net.parameters(),weight_decay=0.001) # Adam优化器
model.losses = {‘types’: [ppseg.models.CrossEntropyLoss(), ppseg.models.DiceLoss()], ‘coef’: [1.0, 1.0]}
In [ ]

调用PaddleRS API实现一键训练

model.train(
num_epochs=NUM_EPOCHS,
train_dataset=train_dataset,
train_batch_size=TRAIN_BATCH_SIZE,
eval_dataset=eval_dataset,
optimizer=optimizer,
save_interval_epochs=SAVE_INTERVAL_EPOCHS,
# 每多少次迭代记录一次日志
log_interval_steps=8,
save_dir=EXP_DIR,
# 是否使用early stopping策略，当精度不再改善时提前终止训练
early_stop=False,
# 是否启用VisualDL日志功能
use_vdl=True,
# 指定从某个检查点继续训练
resume_checkpoint=None
)
模型推理
模型推理和官方baseline一致，使用V100 32G推理总时长约为6分钟。

推理脚本使用固定阈值法从变化概率图获取二值变化图（binary change map），采用了默认阈值0.5。

模型前向推理结果存储在EXP_DIR目录下的out子目录中，可将该子目录内的文件打包、并将压缩文件重命名后提交到比赛系统。

In [15]

定义推理阶段使用的数据集

class InferDataset(paddle.io.Dataset):
“”"
变化检测推理数据集。

Args:
    data_dir (str): 数据集所在的目录路径。
    transforms (paddlers.transforms.Compose): 需要执行的数据变换操作。
"""

def __init__(
    self,
    data_dir,
    transforms
):
    super().__init__()

    self.data_dir = data_dir
    self.transforms = deepcopy(transforms)

    pdrs.transforms.arrange_transforms(
        model_type='changedetector',
        transforms=self.transforms,
        mode='test'
    )

    with open(osp.join(data_dir, 'test.txt'), 'r') as f:
        lines = f.read()
        lines = lines.strip().split('\n')

    samples = []
    names = []
    for line in lines:
        items = line.strip().split(' ')
        items = list(map(pdrs.utils.path_normalization, items))
        item_dict = {
            'image_t1': osp.join(data_dir, items[0]),
            'image_t2': osp.join(data_dir, items[1])
        }
        samples.append(item_dict)
        names.append(osp.basename(items[0]))

    self.samples = samples
    self.names = names

def __getitem__(self, idx):
    name = self.names[idx]
    sample = deepcopy(self.samples[idx])
    output = self.transforms(sample)
    return name, \
           paddle.to_tensor(output[0]), \
           paddle.to_tensor(output[1]),

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

In [16]

考虑到原始影像尺寸较大，以下类和函数与影像裁块-拼接有关。

class WindowGenerator:
def init(self, h, w, ch, cw, si=1, sj=1):
self.h = h
self.w = w
self.ch = ch
self.cw = cw
if self.h < self.ch or self.w < self.cw:
raise NotImplementedError
self.si = si
self.sj = sj
self._i, self._j = 0, 0

def __next__(self):
    # 列优先移动（C-order）
    if self._i > self.h:
        raise StopIteration
    
    bottom = min(self._i+self.ch, self.h)
    right = min(self._j+self.cw, self.w)
    top = max(0, bottom-self.ch)
    left = max(0, right-self.cw)

    if self._j >= self.w-self.cw:
        if self._i >= self.h-self.ch:
            # 设置一个非法值，使得迭代可以early stop
            self._i = self.h+1
        self._goto_next_row()
    else:
        self._j += self.sj
        if self._j > self.w:
            self._goto_next_row()

    return slice(top, bottom, 1), slice(left, right, 1)

def __iter__(self):
    return self

def _goto_next_row(self):
    self._i += self.si
    self._j = 0

def crop_patches(dataloader, ori_size, window_size, stride):
“”"
将dataloader中的数据裁块。

Args:
    dataloader (paddle.io.DataLoader): 可迭代对象，能够产生原始样本（每个样本中包含任意数量影像）。
    ori_size (tuple): 原始影像的长和宽，表示为二元组形式(h,w)。
    window_size (int): 裁块大小。
    stride (int): 裁块使用的滑窗每次在水平或垂直方向上移动的像素数。

Returns:
    一个生成器，能够产生iter(`dataloader`)中每一项的裁块结果。一幅图像产生的块在batch维度拼接。例如，当`ori_size`为1024，而
        `window_size`和`stride`均为512时，`crop_patches`返回的每一项的batch_size都将是iter(`dataloader`)中对应项的4倍。
"""

for name, *ims in dataloader:
    ims = list(ims)
    h, w = ori_size
    win_gen = WindowGenerator(h, w, window_size, window_size, stride, stride)
    all_patches = []
    for rows, cols in win_gen:
        # NOTE: 此处不能使用生成器，否则因为lazy evaluation的缘故会导致结果不是预期的
        patches = [im[...,rows,cols] for im in ims]
        all_patches.append(patches)
    yield name[0], tuple(map(partial(paddle.concat, axis=0), zip(*all_patches)))

def recons_prob_map(patches, ori_size, window_size, stride):
“”“从裁块结果重建原始尺寸影像，与crop_patches相对应”“”
# NOTE: 目前只能处理batch size为1的情况
h, w = ori_size
win_gen = WindowGenerator(h, w, window_size, window_size, stride, stride)
prob_map = np.zeros((h,w), dtype=np.float)
cnt = np.zeros((h,w), dtype=np.float)
# XXX: 需要保证win_gen与patches具有相同长度。此处未做检查
for (rows, cols), patch in zip(win_gen, patches):
prob_map[rows, cols] += patch
cnt[rows, cols] += 1
prob_map /= cnt
return prob_map
In [30]

若输出目录不存在，则新建之（递归创建目录）

out_dir = osp.join(EXP_DIR, ‘out’)
if not osp.exists(out_dir):
os.makedirs(out_dir)

为模型加载历史最佳权重

state_dict = paddle.load(BEST_CKP_PATH)

同样通过net属性访问组网对象

model.net.set_state_dict(state_dict)

实例化测试集

test_dataset = InferDataset(
DATA_DIR,
# 注意，测试阶段使用的归一化方式需与训练时相同
T.Compose([
T.Normalize(
mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5]
)
])
)

创建DataLoader

test_dataloader = paddle.io.DataLoader(
test_dataset,
batch_size=1,
shuffle=False,
num_workers=0,
drop_last=False,
return_list=True
)
In [31]

推理过程主循环

info(“模型推理开始”)

model.net.eval()
len_test = len(test_dataset)
test_patches = crop_patches(
test_dataloader,
ORIGINAL_SIZE,
CROP_SIZE,
STRIDE
)
with paddle.no_grad():
for name, (t1, t2) in tqdm(test_patches, total=len_test):
shape = paddle.shape(t1)
pred = paddle.zeros(shape=(shape[0],2,*shape[2:]))
for i in range(0, shape[0], INFER_BATCH_SIZE):
pred[i:i+INFER_BATCH_SIZE] = model.net(t1[i:i+INFER_BATCH_SIZE], t2[i:i+INFER_BATCH_SIZE])[0]
# 取softmax结果的第1（从0开始计数）个通道的输出作为变化概率
prob = paddle.nn.functional.softmax(pred, axis=1)[:,1]
# 由patch重建完整概率图
prob = recons_prob_map(prob.numpy(), ORIGINAL_SIZE, CROP_SIZE, STRIDE)
# 默认将阈值设置为0.5，即，将变化概率大于0.5的像素点分为变化类
out = quantize(prob>0.5)

    imsave(osp.join(out_dir, name), out, check_contrast=False)

info(“模型推理完成”)

模型推理开始
100%|██████████| 363/363 [05:56<00:00, 1.02it/s]
模型推理完成
后处理策略
删去了检测出的面积小于200的建筑物（大部分应该都是噪声），同时去掉了建筑物内部面积小于1600的孔洞。

In [34]

将推理结果打包并压缩为zip文件。如果修改了默认输出目录，也需要在此指令中做出对应修改。

官方typo: submission -> submisson

!zip -j submisson.zip /home/aistudio/exp/out/* > /dev/null
参考资料
遥感数据介绍
PaddleRS文档