【HSI】高光谱的数据集分类深度学习实战及代码理解 |
您所在的位置：网站首页 › 基于python的数据集划分 › 【HSI】高光谱的数据集分类深度学习实战及代码理解 |
【HSI】高光谱的数据集分类深度学习实战及代码理解
|
【HSI】高光谱的数据集分类深度学习实战及代码理解
文章目录
【HSI】高光谱的数据集分类深度学习实战及代码理解一、配置文件编写二、高光谱图像的处理2.1图像数据变换2.2 数据整合2.3 数据索引
三、数据集四、深度学习模型五、训练，测试及图像展示六、主函数的理解
对整个工程的代码框架划分
将整个深度学习的框架基本划分为： 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) 三、数据集在深度学习的过程中，主要使用了高光谱图像作为数据集来进行训练 读取存放文件的地址位，来调用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深度学习的代码框架，以这个框架在相应的文件子函数中进行编写和修改，但进行不同模型的训练最主要的还是修改不同的模型和训练集，对模型准确度的判定都差不多 |
数据集的格式为mat文件
【本文地址】
今日新闻 |
推荐新闻 |