深度学习(五)之原型网络

在本文中,将介绍一些关于小样本学习的相关知识,以及介绍如何使用pytorch构建一个原型网络(Prototypical Networks[1]),并应用于miniImageNet 数据集。

实验环境:

pytorch:1.11.0
代码地址:https://github.com/xiaohuiduan/deeplearning-study/tree/main/小样本学习

小样本学习引入

在这一节将简要的对小样本学习(FSL)相关的知识进行介绍。由于我并不是专门研究小样本的(我学习FSL也只是为了完成我的课程作业),因此,如果本文存在任何问题,欢迎进行批评指正?。

邮箱?:xiaohuiduan@hunnu.edu.cn

首先将模型看成一个黑盒子,不去关注它的内部结构,而是关注其inputoutput

在分类模型[2]中,input是一张猫or狗的图片,output则为0/1(代表其为猫或者狗;实际上输出的是两者的预测概率)。

但是关于上面的模型,存在一个问题,训练这样的模型需要大量的数据,根据@petewarden[3]的说法,训练一个分类图片的网络,每个类别需要大约1000张。但是,很多场景我们并没有足够的数据进行训练,也就是说数据集的样本比较少,这时候针对小样本数据集可以有两种处理方式[4]

  • 数据增强:比如说对图像进行旋转,裁剪等等。
  • 数据建模:如使用小样本学习的方法进行对数据进行建模。

小样本学习是什么

以VGG模型预测猫狗分类举例,模型对于一张新的图片的预测可以形象的解释为:

图片中的动物因为有着尖尖的耳朵,有着较长的胡须,鼻子那一个地方不是很突出,因此,我(VGG)判断它是一只猫o(=•ェ•=)m。

但是在小样本学习中,不是这样的,小样本学习对于一张新的图片的预测可以形象的解释为:

我手中有2张图片,图片A和图片B。对于新的图片,我(模型)也不知道他是啥,但是我发现它跟图片B长得很相似,因此我(模型)判断这张新的图片和图片B是同一个类别。

在上述解释中,图片A和B称之为support sets,而新的图片称之为query sets

小样本的分类模型与传统的深度学习分类模型(如VGG)有着不同,这里引用论文[1:1]的一句话:

Few-shot classification is a task in which a classifier must be adapted to accommodate
new classes not seen in training, given only a few examples of each of these classes. A naive approach,
such as re-training the model on the new data, would severely overfit.

也就是说,小样本分类并不是像VGG一样,test的数据是以前训练过的类别,对于小样本分类来说,进行test的数据是一些新的类,并且这些类别的样本很少,因此,没法对其进行re-training,否则会造成过拟合。

小样本学习方法

小样本学习可以认为是一个N-way K-shot的分类问题(不确定是不是所有的小样本分类任务都被认为是N-way K-shot分类问题)。

无论对于测试集还是训练集,都需要进行如下的划分,将数据集划分为两个部分:左边DataSet代表数据集,右边分别代表Support set,右边代表Query Set。在train或者test数据集中:

  1. 首先对于所有类别,随机选择其中N(图中N=3)个类别(图中,选择了类别2,类别3和类别5)。
  2. 在step 1中选择的类别样本中,随机选择K(图中K=3)个样本(绿色的部分),构成Support Set。也就是说,Support Set中拥有K*N个样本。
  3. 然后在所选择类别的剩余样本中,选择X(这里X=1)个样本(红色的部分),构成Query Set。也就是说,Query Set中拥有X*N个样本。

在训练集中,以上步骤构成的Support Set和Query Set会被input到Model中进行训练,称之为一个eposides(相当于mini-batch)。

对于模型来说,其目的则为判断Query Set中的样本与哪一个支持集最相似

原型网络(Prototype Network)

原理简述

Prototype Network的原理很简单,可以简单的概括为:将support set中的图片/(data_1,data_2,/cdots,data_n/)映射到某一个向量空间/(c_1,c_2,/cdots,c_n/);对于Query set中的某一张图片/(query_i/)使用同一个映射函数,也映射到到向量空间/(x_i/),然后判断/(x_i/)/(c_1,c_2,/cdots,c_n/)的距离(余弦距离or欧氏距离),选择距离最近向量所对应的类别作为/(query_i/)所属的类别。

示意图[5]如下所示:

如果了解NLP中word2vec的话,会发现,其与word2vec的Embedding思想是很相似的。

算法流程

算法流程图[1:2]如下所示,红色框和绿色框中的过程已经在前文进行介绍,这里主要是来介绍一下loss的计算方式。

image-20220507144721234

实际上,loss的计算方式就是一个交叉熵损失函数,pytorch中CrossEntropyLoss的计算方法如下所示,class代表/(x/)实际所属类别/(x[j]/)代表模型对于/(x/)所属类别/(j/)的概率预测。

/[/operatorname{loss}(x, /text { class })=-/log /left(/frac{/exp (x[/text { class }])}{/sum_{j} /exp (x[j])}/right)=-x[/text { class }]+/log /left(/sum_{j} /exp (x[j])/right) /]

但是,在算法流程图中,大家会发现,其loss计算的正负号刚好与上面公式中的相反,解释如下:

以欧式距离为例,距离越远(/(d/)则越大),则代表两者的相似度越低。如果不加负号的话,进行softmax计算,距离越远的则predict概率越大,这明显是错误的。因此,加了一个负号之后,距离越远,进行softmax之后,输出则越小,predict的概率也变小,这才是合理的。

以上,便是原型网络的算法流程。

算法实现

数据集处理

mini-Imagenet是一个专门用于训练小样本学习的训练集,数据集中一共有100个类别,每个类别600张图片,一共有60000张图片。数据集可以从mini-ImageNet | Kaggles上面下载。在下载文件中,一共有4个文件,一个是数据集图片的压缩包,另外3个csv文件分别代表了训练、验证和测试集相关的信息。其中训练集有64个类,验证集16个类,测试集20个类。

csv的部分数据如下所示,filename代表了图片的名字,label代表了图片对应的标签。

因此,可以构建一个label所对应filename的字典

def read_csv(csv_path):     dict = collections.defaultdict(list)     df = pd.read_csv(csv_path)     for index,row in df.iterrows():         dict[row["label"]].append(row["filename"])     return dict train_dict = read_csv(train_csv_path) val_dict = read_csv(val_csv_path) test_dict = read_csv(test_csv_path) 

同时,构建data与labels的对应关系:

from PIL import Image import numpy as np from torchvision import transforms from PIL import ImageFile ImageFile.LOAD_TRUNCATED_IMAGES = True  resize_transform = transforms.Resize(84) # 提前对图片进行缩放,以节省内存空间,将最短的边变成84 def build_data(data_dict):     datas = []     labels = []     label_index = 0     for label in data_dict.keys(): # 对图片的标签进行迭代         for path in data_dict[label]: # 对标签对应的文件名进行迭代             img_path = os.path.join(img_root_dir,path)              img = Image.open(img_path) # 读取文件             img = resize_transform(img) # 进行缩放             datas.append(img)              labels.append(label_index)          label_index += 1     return {"datas":datas,"labels":labels} 

随机产生Support set 和 Query set

在下面代码中,CategoriesSampler的作用是为了产生index,然后供给dataloader使用。

class CategoriesSampler():     """         目的是为了随机产生K_way*(N_support+N_query)个图片对应的index     """     def __init__(self, data, n_batch, K_way, N_per):         self.n_batch = n_batch         self.K_way = K_way         self.N_per = N_per         labels = np.array(data["labels"]) # [0,0,0,0,1,1,1,1,2,2,2,2……]         self.index = [] # 记录label对应的索引位置         for i in range(max(labels)+1):             ind = np.argwhere(labels == i).reshape(-1)             self.index.append(torch.from_numpy(ind))         def __len__(self):         return self.n_batch          def __iter__(self):         for i_batch in range(self.n_batch):               batch = []             classes = torch.randperm(len(self.index))[:self.K_way] # 随机选择K个类别构成support set和query set             for c in classes:                 l = self.index[c] # 类别c对应的图片数组的索引,如 l = [5,6,7,8,9]                 pos = torch.randperm(len(l))[:self.N_per] # 如 pos = [4,1,0]                 batch.append(l[pos]) # 如 l[pos] = [9,6,5]              batch = torch.stack(batch).reshape(-1)             yield batch 

同时,定义Dataset类,如下:

class MiniImageNet(Dataset):      def __init__(self, data):          self.datas = data["datas"]         self.labels = data["labels"]         self.transform = transforms.Compose([             transforms.CenterCrop(84),             transforms.ToTensor(),             transforms.Normalize(mean=[0.485, 0.456, 0.406],                                  std=[0.229, 0.224, 0.225])         ])      def __len__(self):         return len(self.datas)      def __getitem__(self, i):         img, label = self.datas[i], self.labels[i]         return self.transform(img), label 

使用示例如下,在MiniImageNet的__getitem__函数中,其参数iCategoriesSampler__iter__函数所产生。

batch_sampler = CategoriesSampler(datas,eval_step,K_way,N_shot+N_query) data_loader = DataLoader(dataset=data_set, batch_sampler=batch_sampler,                                             num_workers=16, pin_memory=True) 

实际上,上面的代码就是为了实现如下图所示的功能:

Embedding网络构建

前文说到,需要将图片进行向量化表示,在下面的代码中,便可以将一张图片(shape=/(3/times84/times84/))变成一个1600维的向量。(网络结构来自于论文)

class CNN_Net(nn.Module):     """         用于特征提取     """      def __init__(self, input_dim):         super(CNN_Net, self).__init__()                  self.input_dim = input_dim         def conv_block(in_channel,out_channel):             return nn.Sequential(                 nn.Conv2d(in_channel, out_channel, 3,padding=1),                 nn.BatchNorm2d(out_channel),                 nn.ReLU(),                 nn.MaxPool2d(2)             )         self.encoder = nn.Sequential(             conv_block(input_dim,64),             conv_block(64,64),             conv_block(64,64),             conv_block(64,64),         )     def forward(self, x):         x = self.encoder(x)         x = x.view(x.size(0), -1)         return x 

损失函数

关于计算损失的关键函数如下所示(参考了论文作者的源代码[6]):

def cal_euc_distance(self, query_z, center,K_way, N_query):     """         计算query_z与center的距离         query_z : (K_way*N_query,z_dim)         center : (K_way,z_dim)     """     center = center.unsqueeze(0).expand(         K_way*N_query, K_way, self.z_dim)  # (K_way*N_query,K_way,z_dim)     query_z = query_z.unsqueeze(1).expand(         K_way*N_query, K_way, self.z_dim)  # (K_way*N_query,K_way,z_dim)      return torch.pow(query_z-center, 2).sum(2)  # (K_way*N_query,K_way)  def loss_acc(self, query_z, center, K_way, N_query):     """         计算loss和acc         query_z : (K_way*N_query,z_dim)         center : (K_way,z_dim)     """     target_inds = torch.arange(0, K_way).view(K_way, 1).expand(         K_way, N_query).long().to(self.device) # shape=(K_way, N_query)          distance = self.cal_euc_distance(query_z, center,K_way, N_query)    # (K_way*N_query,K_way)      predict_label = torch.argmin(distance, dim=1)  # (K_way*N_query) 预测出来的label      acc = torch.eq(target_inds.contiguous().view(-1),                     predict_label).float().mean() # 准确率      loss = F.log_softmax(-distance, dim=1).view(K_way,                                                 N_query, K_way)  # (K_way,N_query,K_way)     loss = - /         loss.gather(dim=2, index=target_inds.unsqueeze(2)).view(-1).mean()     return loss, acc  def set_forward_loss(self, K_way, N_shot, N_query,sample_datas):     """         sample_datas: shape(K_way*(N_shot+N_query),3,84,84)     """      z = self.cnn_net(sample_datas) # shape=(K_way*(N_shot+N_query),z_dim) ,将support set和query set都进行向量化表示     z = z.view(K_way,N_shot+N_query,-1) # shape = (K_way,N_shot+N_query,1600)          support_z = z[:,:N_shot] # support set的向量化表示 shape=(K_way,N_shot,1600)     query_z = z[:,N_shot:].contiguous().view(K_way*N_query,-1) # Query set的向量化表示 shape=(K_way*N_query,1600)          center = torch.mean(support_z, dim=1) # 计算support set的向量均值,shape=(K_way,1600)     return self.loss_acc(query_z, center,K_way,N_query) 

关于实验中具体的参数设计,可以参考论文[1:3]或者Github上面的源代码。在原论文中,对于实验的设计讲得非常清楚。

实验结果

下面的表格为测试集的acc(当验证集acc为最大值时测试集所对应的acc):

N-shot=1 N-shot=5
K_way=5 0.4313 0.6684

总结

总的来说,原型网络是一个容易理解的网络模型,思想简单,易于实现。

References


  1. [1703.05175] Prototypical Networks for Few-shot Learning (arxiv.org) ↩︎ ↩︎ ↩︎ ↩︎
  2. 深度学习(二)之猫狗分类 – 段小辉 – 博客园 (gaodi.net) ↩︎
  3. How many images do you need to train a neural network? « Pete Warden’s blog ↩︎
  4. 刘颖, 雷研博, 范九伦, 王富平, 公衍超, 田奇. 基于小样本学习的图像分类技术综述. 自动化学报, 2021, 47(2): 297−315 ↩︎
  5. 【Pytorch】prototypical network原型网络小样本图像分类简述及其实现_Jnchin的博客-CSDN博客_原型网络小样本 ↩︎
  6. jakesnell/prototypical-networks: Code for the NeurIPS 2017 Paper “Prototypical Networks for Few-shot Learning” (github.com) ↩︎

商匡云商
Logo
注册新帐户
对比商品
  • 合计 (0)
对比
0
购物车