【HSI】高光谱的数据集分类深度学习实战及代码理解

对整个工程的代码框架划分

将整个深度学习的框架基本划分为：

• configs:配置文件
• data:处理数据高光谱图像数据
• datasets:数据集存放
• model:深度学习训练模型
• tool:用于模型的训练、测试和图像的展示
• weights:梯度权重值的保存
• main:主函数的运行

在不同的文件下面进行相应的编写，同时便于阅读和后续的修改和移植性的提高

一、配置文件编写

datasets_type = 'HSI Data Sets'
data_root = '/home/students/master/2022/wangzy/PyCharm-Remote/HSIC_train/datasets/PaviaU.mat'
image_name = 'paviaU'
gt_name = 'paviaU_gt'  # 在数据库上标注好的label一般被默认为是真实的值，也就是GT了


phase = ['train', 'test', 'no_gt']
pca_num = 1
train_set_num = 30
patch_size = 27

data = dict(
    data_path=data_root,
    image_name=image_name,
    gt_name=gt_name,
    train_set_num=train_set_num,
    patch_size=patch_size,
    pca=pca_num,
    train_data=dict(
        phase=phase[0]
    ),
    test_data=dict(
        phase=phase[1]
    ),
    no_gt_data=dict(
        phase=phase[2]
    )
)
train = dict(
    # 优化器的相应数据
    optimizer=dict(
        typename='SGD',
        lr=lr,
        momentum=0.9,  # 动量
        weight_decay=1e-4  # 权重衰减
    ),

    train_model=dict(
        gpu_train=True,
        gpu_num=1,
        workers_num=16,
        epoch=100,
        batch_size=32,
        # 学习率的相应参数
        lr=lr,
        lr_adjust=True,
        lr_gamma=0.1,
        lr_step=60,
        save_folder='./weights/',
        save_name='model_CNN1D',
        reuse_model=False,
        reuse_file='./weights/model_CNN1D_Final.pth'
    )
)

test = dict(
    batch_size=1000,
    gpu_train=True,
    gpu_num=1,
    workers_num=16,
    model_weights='./weights/model_CNN1D_Final.pth',
    save_folder='./result'
)

配置文件的编写主要是为了，在后续调整模型时，方便修改相应的数据参数，常用的使用和调整的包含了：

data_root = '/home/students/master/2022/wangzy/PyCharm-Remote/HSIC_train/datasets/PaviaU.mat'   #高光谱数据集
lr = 1e-2		#学习步长
pca_num = 1		#高光谱图像PCA后的通道数
train_set_num = 30		#训练的次数
patch_size = 27			#对高光谱数据集划分patch的尺寸 27*27
epoch=100,				#epoch的次数
batch_size=32,			#图像的数量

在训练模型调参时，基本的改动都在configs的文件中来进行修改

二、高光谱图像的处理

2.1图像数据变换

在现在的处理中，主要时mat文件的导入，一张图像的数据大体上分为了[W,H,C]，长宽和通道数，以paviaU数据集来进行举例，torch([32, 103, 610, 340])，大约包含了这些参数，32为图片数量，103的通道数和[610,340]的长宽

对原始图像的处理基本分为：

• 图像数据归一化
• 标签转换
• 提取PCA图像数据
• 构建样本和划分训练集，测试集和地图信息

可以根据自己对图像处理的需求来构建相应的子函数

（1）图像数据归一化

def one_zero_norm(image):
    channel, height, width = image.shape
    data = image.view(channel, height * width)
    data_max = data.max(dim=1)[0]
    data_min = data.min(dim=1)[0]

    data = (data - data_min.unsqueeze(1)) / (data_max.unsqueeze(1) - data_min.unsqueeze(1))  # 在第二个维度上插入一个维度

    return data.view(channel, height, width)
def pos_neg_norm(image):
    channel, height, width = image.shape
    data = image.view(channel, height * width)
    data_max = data.max(dim=1)[0]
    data_min = data.min(dim=1)[0]

    data = -1 + 2 * (data - data_min.unsqueeze(1)) / (data_max.unsqueeze(1) - data_min.unsqueeze(1))

    return data.view(channel, height, width)
def std_norm(image):
    image = image.permute(1, 2, 0).numpy()
    trans = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize(torch.tensor(image).mean(dim=[0, 1]), torch.tensor(image).std(dim=[0, 1]))
    ])

    return trans(image)

根据要求的不同来对图像进行相应的处理

# (x - mean(x))/std(x) normalize to mean: 0, std: 1
# (x - min(x))/(max(x) - min(x))  normalize to (0, 1) for each channel
# -1 + 2 * (x - min(x))/(max(x) - min(x))  normalize to (-1, 1) for each channel

数据的分布范围不同，采用不同的函数

（2）标签转换

def label_transform(gt):
    '''
        function：tensor label to 0-n for training
        input: gt
        output：gt
        tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
        -> tensor([-1.,  0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])
    '''
    label = torch.unique(gt)  # 返回标签label中的不同值
    gt_new = torch.zeros_like(gt)  # zeros_like(a)的目的是构建一个与a同维度的数组，并初始化所有变量为零。
    # zeros,则需要代入参数

    for each in range(len(label)):  # 长度为10
        indices = torch.where(gt == label[each])

        if label[0] == 0:
            gt_new[indices] = each - 1
        else:
            gt_new[indices] = each

    # tensor([-1.,  0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])
    # labeL_new = torch.unique(gt_new)

    return gt_new

将标签依次向下减小，将图像的背景label定义为-1，从而使标签信息可以分隔开来

（3）提取PCA图像数据

高光谱的数据通道数太多了，进行空间卷积的话，会受到影响，通过PCA下降后更方便进行2D卷积

def extract_pc(image, pc=3):

    channel, height, width = image.shape
    data = image.contiguous().reshape(channel, height * width) # 存在contiguous函数，在改变data的值后
    data_c = data - data.mean(dim=1).unsqueeze(1)
    # 计算一个矩阵或一批矩阵 input 的奇异值分解
    u, s, v = torch.svd(data_c.matmul(data_c.T)) # data_c矩阵乘以data_c的转置
    sorted_data, indices = s.sort(descending=True) # 将s中的数按降序进行排列
    image_pc = u[:, indices[0:pc]].T.matmul(data)
    return image_pc.reshape(pc, height, width)

（4）构建样本和划分训练集，测试集和地图信息

def select_sample(gt, ntr):

构建函数用于划分数据集的数量和返回相应的参数

train_num_array = [30, 150, 150, 100, 150, 150, 20, 150, 15, 150, 150, 150, 150, 150, 50, 50]
sel_num = train_num_array[each-1]

sel_num = torch.tensor(sel_num)  # tensor(30)

# 将标签进行打乱
rand_indices0 = torch.randperm(class_num)  # torch.randperm 给定参数n，返回一个从0到n-1的随机整数排列
rand_indices = indices_vector[rand_indices0]

# 划分训练集train,测试集test
# 划分打乱后的随机整数排列
tr_ind0 = rand_indices0[0:sel_num]  # torch.Size([30])
te_ind0 = rand_indices0[sel_num:]  # 将剩下的数据用作测试集

# 划分随机整数排列对应的gt
tr_ind = rand_indices[0:sel_num]  # torch.Size([30])
te_ind = rand_indices[sel_num:]

以数组的形式来存储数据集中不同类别的训练集和划分数据集，将相应的数据和指标进行划分来存储和返回

# 将6种数据参数进行保存
data_sample = {'train_indices': train_indices, 'train_num': train_num,
               'test_indices': test_indices, 'test_num': test_num,
               'no_gt_indices': no_gt_indices, 'no_gt_num': no_gt_num.unsqueeze(0)
               }

2.2 数据整合

def get_train_test_set(cfg):

    # 从cfg中导入设定好的参数
    data_path = cfg['data_path']  # 导入存放的地址
    image_name = cfg['image_name']  # paviaU
    # 这个其实就是103通道的整个图像的信息

    gt_name = cfg['gt_name']  # 'paviaU_gt'
    # 这个是地图的特征信息，同时具有标签值
    # [0,0,1,1,1,4,4,4,]这种的标签图

    train_set_num = cfg['train_set_num']  # 30,每一次数据集训练的次数
    patch_size = cfg['patch_size']  # 27,用于切分图像的尺寸
    
    data = io.loadmat(data_path)  # 从相应的文件夹导入

    img = data[image_name].astype('float32')  # .astype转换数组的数据类型  (610, 340, 103) [w,h,c]
    gt = data[gt_name].astype('float32')  # 转换成float32  (610, 340) ,这个数据从数据库中导入，只有一个数据

    img = torch.from_numpy(img)  # 转tensor   # torch.Size(610, 340, 103)
    gt = torch.from_numpy(gt)  # torch.Size(610, 340)

    img = img.permute(2, 0, 1)  # 变换tensor的维度,把channel放到第一维CxHxW  # torch.Size(103, 610, 340)
    img = pre_fun.std_norm(img)  # 归一化，torch.Size(103, 610, 340) 将数据分布在（0，1）之间

    # label transform  0~9 -> -1~8
    # 将标签值进行转换，应该在mat文件中，对不同的物体的label值就做好了定义
    img_gt = pre_fun.label_transform(gt)  # torch.size(610, 340)

    # construct_sample：切分patch，储存每个patch的坐标值
    # img_pad的值为([103, 636, 366]),
    # img_pad_indices的值为([207400, 4])
    img_pad, img_pad_indices = pre_fun.construct_sample(img, patch_size)

    # (1)select_sample：用img_gt的标签信息划分样本
    # (2)得到的data_sample = {'train_indices': train_indices, 'train_num': train_num,
    #                    'test_indices': test_indices, 'test_num': test_num,
    #                    'no_gt_indices': no_gt_indices, 'no_gt_num': no_gt_num.unsqueeze(0)
    #                    }
    data_sample = pre_fun.select_sample(img_gt, train_set_num)

    # data_sample再添加几项数据
    data_sample['pad_img'] = img_pad
    data_sample['pad_img_indices'] = img_pad_indices
    data_sample['img_gt'] = img_gt  # 转化后的特征标签图的数据
    data_sample['ori_gt'] = gt  # 原始特征标签图的数据

    # print('data_sample.keys()',data_sample.keys())
    # dict_keys(['train_indices', 'train_num', 'test_indices', 'test_num',
    # 'no_gt_indices', 'no_gt_num', 'pad_img', 'pad_img_indices', 'img_gt', 'ori_gt'])

    if cfg['pca'] > 0:
        img_pca = pre_fun.extract_pc(img, cfg['pca'])
        img_pca = pre_fun.one_zero_norm(img_pca)
        img_pca = pre_fun.std_norm(img_pca)

        img_pca_pad, _ = pre_fun.construct_sample(img_pca, patch_size)

        data_sample['img_pca_pad'] = img_pca_pad

    return data_sample

主要功能：

• 数据集train,test
• 加载数据集，转化为tensor，label transform，
• 切分patch，储存每个patch的坐标值，
• 由gt划分样本，最终得到data_sample

在这个函数中主要调用2.1中构建的子函数，来对图像数据进行处理，储存相应的处理完的图像数据

输出参数：

• ‘train_indices’, ‘train_num’, 训练集的坐标，训练集的数目

• ‘test_indices’, ‘test_num’, 测试集的坐标，测试集的数目

• ‘no_gt_indices’, ‘no_gt_num’, 背景图的坐标和数目

• ‘pad_img’, ‘pad_img_indices’, patch后的图像数据和坐标

• ‘img_gt’, ‘ori_gt’ 图像划分的原始数据

2.3 数据索引

主要使用的是class HSI_data(data.Dataset)，将get_train_test_set(cfg)返回的参数进行带入

（1）函数作用

def __getitem__(self, idx):

来对具体的数值进行提取，根据之前训练集，测试集划分的不同，会返回相应的不同的长度，在编写训练函数的时候，借由

batch_data = DataLoader(train_data, batch_size, shuffle=True, \
                        num_workers=num_workers, collate_fn=collate_fn, pin_memory=True)

这种形式将相应的数据通过Dataloader来进行加载读入，从而在设定好的epoch里面实现训练

（2）返回的参数

index = self.data_indices[idx]
img_index = self.img_indices[index[0]]  # img_index 坐标

# 从pad_img中根据坐标截取样本
img = self.img[:, img_index[0]:img_index[1], img_index[2]:img_index[3]]
label = self.gt[index[1], index[2]]

以idx来随机定位相应的索引的数据，返回图像数据为（可以根据自己的需求来进行返回）：

• img, 光谱图像信息（原始信息） tensor(103,27,27)
• label, 标签值
• index, 相应的坐标（在前面的函数中，将打平的一维坐标和2个二维位标都进行了保存）
• img_pca 空间图像信息（PCA处理后）tensor(1,27,27)

三、数据集

在深度学习的过程中，主要使用了高光谱图像作为数据集来进行训练

数据集的格式为mat文件

matdata = scio.loadmat(data_root)
print(matdata.keys())  # 查看mat数据集的key

dict_keys(['__header__', '__version__', '__globals__', 'fea', 'gnd', 'paviaU', 'paviaU_gt'])

读取存放文件的地址位，来调用loadmat读取相应的数据，返回字典中的keys,来查看数据集中存在哪几类数据来进行调用

在读取数据集时，不仅要注意图像的【C,H,W】，还需要注意其中的，keys的选择

例如：

data_root = '/home/students/master/2022/wangzy/PyCharm-Remote/datasets/PaviaU.mat'
image_name = 'paviaU'
gt_name = 'paviaU_gt'
# paviaU的特征分为了9类
# torch([32, 103, 610, 340])

data_root = '/home/students/master/2022/wangzy/PyCharm-Remote/datasets/Indian_pines.mat'
image_name = 'indian_pines_corrected'
gt_name = 'R'
# indian_pines的特征分为了16类
# torch([32, 220, 145, 145])

  paviaU的特征分类为9，在最后模型的全连接过程分类应该为9，在使用不同的数据集时需要注意特征数的不同，indian_pines的特征分为了16类。

  数据集在训练的时候一般会分为空间信息和光谱信息，空间信息一般是pca处理后进行，通道数自己定义，光谱信息一般是对单像素的进行处理，在调用的时候，patch处理后的img图像正中间就是对应的图像原始像素点的数据。

四、深度学习模型

  在整个编写的过程中主要就是模型的编写，其他的部分基本是理解完成后进行细微的调整，这里用最基本的CNN2D来举例

class CNN2D(nn.Module):
    def __init__(self, in_fea_num, out_fea_num):
        super(CNN2D, self).__init__()
        self.conv1 = nn.Conv2d(in_fea_num, 32, kernel_size=4, stride=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=5, stride=1)
        self.fc = nn.Linear(64, out_fea_num)

    def forward(self, origin_data, pca_data):
        output = self.conv1(pca_data)
        output = F.relu(output)
        output = F.max_pool2d(output, 2)
        output = self.conv2(output)
        output = F.relu(output)
        output = torch.flatten(output, 1)
        output = self.fc(output)

        return output

def main():
    net = CNN2D(1, 9)
    tmp = torch.randn(32, 1, 27, 27)
    out = net(tmp)
    print(out.shape)

  这是一个最基本的2D卷积神经网络，2个卷积层，中间插入relu和max_pool来实现卷积，最后进行相应的全连接

  输入的是img_pca,这里是对HSI的空间信息进行处理，一般的空间卷积都是使用pca降维后的来进行使用，因为最后的paviaU的特征分为了9类，所以在后面的全连接层最后输出的为9，代表对9类特征值的判断概率

五、训练，测试及图像展示

  训练和测试模型基本上的代码框架差不多，在后面主要就是介绍训练模型使用的代码框架的理解，主体上包含了以下部分：

• 导入之前设定的参数值

• 加载模型和设定是否采用上次编写的来进行训练

• 在设定的epoch中进行数据的遍历

• 训练模型和存储

• 打印数据

（1）导入之前设定的参数值

num_workers = cfg['workers_num']  # 导入同时工作的线程数
gpu_num = cfg['gpu_num']  # 几个GPU工作

save_folder = cfg['save_folder']  #'./weights/'
save_name = cfg['save_name']      #'model_CNN1D'

lr_init = cfg['lr']
lr_gamma = cfg['lr_gamma']
lr_step = cfg['lr_step']  # 步进为60
lr_adjust = cfg['lr_adjust']  # 设置为Ture

epoch_size = cfg['epoch']
batch_size = cfg['batch_size']

主要是导入在初始文件configs中的设定值，在后面的修改中也基本是在configs里进行相应的修改

（2）加载模型和设定是否采用上次编写的来进行训练

if gpu_num > 1 and cfg['gpu_train']:
    # 采用多卡GPU服务器
    model = torch.nn.DataParallel(model).to(device)
    # 使用样例
    # model = model.cuda()
    # device_ids = [0, 1]  # id为0和1的两块显卡
    # model = torch.nn.DataParallel(model, device_ids=device_ids)
else:
    model = model.to(device)

model.train()

if cfg['reuse_model']:

    print('loading model')
    checkpoint = torch.load(cfg['reuse_file'], map_location=device)  # 用来加载torch.save() 保存的模型文件
    start_epoch = checkpoint['epoch']
    model_dict = model.state_dict()  # state_dict其实就是一个字典，该自点中包含了模型各层和其参数tensor的对应关系。
    pretrained_dict = {k: v for k, v in checkpoint['model'].item() if k in model_dict}  # 再用预训练模型参数更新model_dict
    model_dict.update(pretrained_dict)
    model.load_state_dict(model_dict)  # 装载已经训练好的模型
else:
    start_epoch = 0

可以通过选择是否采用上一次的模型或者，重新开始训练新的模型

（3）在设定的epoch中进行数据的遍历

for epoch in range(start_epoch + 1, epoch_size + 1):
    epoch_time0 = time.time() 
    batch_data = DataLoader(train_data, batch_size, shuffle=True, \
                            num_workers=num_workers, collate_fn=collate_fn, pin_memory=True)
    if lr_adjust:
        lr = adjust_lr(lr_init, lr_gamma, optimizer, epoch, lr_step)
    else:
        lr = lr_init
    epoch_loss = 0
    predict_correct = 0
    label_num = 0

    for batch_idx, batch_sample in enumerate(batch_data):  # 遍历加载的数据集
        iteration = (epoch - 1) * batch_num + batch_idx + 1
        batch_time0 = time.time()
        # (1)导入图片和标签
        if len(batch_sample) > 3:
            img, target, indices, img_pca = batch_sample
            img_pca = img_pca.to(device)
        else:
            img, target, indices = batch_sample

        img = img.to(device)
        target = target.to(device)

  在这里主要是在一个中epoch，对图像数据进行导入和遍历，在DataLoader的作用下，batch_size=32决定了一次提取的图片数目，在HSI_Data的索引下，对划分好的训练集进行相应的随机提取，主要是用的是img和img_pca

• img patch后的图像数据（32，103，25，25）
• img_pca patch后pca降维的图像数据（32，1，25，25）

(4)训练模型

# 前向传播
prediction = model(img, img_pca)  # 在CNN2D中只用了img_pca

# 计算损失
loss = loss_fun(prediction, target.long())  # 这里target应该是标签值

# 优化器，反向传播
optimizer.zero_grad()  # 将梯度归零
loss.backward()  # 反向传播计算得到每个参数的梯度值
optimizer.step()  # 通过梯度下降执行一步参数更新

这几步基本上是固定的，先进行前向传播，后面再进行反向传播更新梯度权重

if not os.path.exists(save_folder):
    os.makedirs(save_folder)  # 递归创建目录

 # 存储最终的模型
save_model = dict(
    model=model.state_dict(),
    epoch=epoch_size
)

将训练完成的模型进行存储，用于下次的测试

（5）打印数据

# 将相应的数据进行打印
print('Epoch: {}/{} || lr: {} || loss: {} || Train acc: {:.2f}% || '
      'Epoch time: {:.4f}s || Epoch ETA: {}'
      .format(epoch, epoch_size, lr, epoch_loss/batch_num, 100*predict_correct/label_num,
              epoch_time, str(datetime.timedelta(seconds=epoch_eta))
              )
      )

将相应的参数打印，再训练的过程中可以进行观察

Epoch: 6/100 || lr: 0.01 || loss: 0.3411703225639131 || Train acc: 90.74% || Epoch time: 0.7305s || Epoch ETA: 0:01:08
Epoch: 7/100 || lr: 0.01 || loss: 0.2682735058996413 || Train acc: 90.74% || Epoch time: 0.6298s || Epoch ETA: 0:00:58
Epoch: 8/100 || lr: 0.01 || loss: 0.20451137092378405 || Train acc: 93.33% || Epoch time: 0.5340s || Epoch ETA: 0:00:49
Epoch: 9/100 || lr: 0.01 || loss: 0.2426785926024119 || Train acc: 90.74% || Epoch time: 0.6558s || Epoch ETA: 0:00:59

六、主函数的理解

在main函数文件中，主要是调用前面的包装好的子函数进行调用，很简单和容易理解

主体上分为：

• 基本参数配置
• 加载模型和优化
• 训练测试
• 显示图像

（1）基本参数配置

# 基本参数配置
cfg_data = cfg.data
cfg_model = cfg.model
cfg_train = cfg.train['train_model']
cfg_optim = cfg.train['optimizer']  # 导入优化模型的相应参数
cfg_test = cfg.test

# 数据导入和数据集的划分
data_sets = fun_get_set(cfg_data)

train_data = fun_data(data_sets, cfg_data['train_data'])
test_data = fun_data(data_sets, cfg_data['test_data'])
no_gt_data = fun_data(data_sets, cfg_data['no_gt_data'])

（2）加载模型和优化

device = torch.device("cuda:5")
# 加载模型
model = fun_model(cfg_model['in_fea_num'], cfg_model['out_fea_num']).to(device)
# 损失函数
loss_fun = nn.CrossEntropyLoss()
# 优化器
optimizer = optim.SGD(model.parameters(), lr=cfg_optim['lr'],
                      momentum=cfg_optim['momentum'], weight_decay=cfg_optim['weight_decay'])

（3）训练测试

# 训练
fun_train(train_data, model, loss_fun, optimizer, device, cfg_train)

# 测试
pred_train_label = fun_test(train_data, data_sets['ori_gt'], model, device, cfg_test)
pred_test_label = fun_test(test_data, data_sets['ori_gt'], model, device, cfg_test)
pred_no_gt_label = fun_test(no_gt_data, data_sets['ori_gt'], model, device, cfg_test)

predict_label = torch.cat([pred_train_label, pred_test_label, pred_no_gt_label], dim=0)

(4)显示图像

直接显示相应的图像
HSI = show.Predict_Label2Img(pred_no_gt_label)
plt.imshow(HSI)
plt.show()

  main函数也代表了整个HSI深度学习的代码框架，以这个框架在相应的文件子函数中进行编写和修改，但进行不同模型的训练最主要的还是修改不同的模型和训练集，对模型准确度的判定都差不多