[论文理解] Destruction and Construction Learning for Fine-grained Image Recognition

Destruction and Construction Learning for Fine-grained Image Recognition

Intro

本文提出一种细粒度图像分类的方法,即将原图像拼图一样shuffle成不同的block,丢进一个分类器,当然,直接这样训练会引入shuffle带来的无关噪声,所以又加上了adversarial learning和construction learning,类比自编码器,其实这样的操作是使得网络学习到的feature map更加贴近正常图片的feature map,防止网络输出的feature map引入过多的噪声,从而关注真正对细粒度分类有用的部分。整个过程相当于用三个放大镜,层层筛选,筛选得到不管怎么shuffle都对细粒度分类有用的特征。

整个网络的结构如下图所示,清晰明了:

[论文理解] Destruction and Construction Learning for Fine-grained Image Recognition_第1张图片

Region Confusion Mechanism

这一部分是“拼图”打乱的过程。

文章中对该部分的描述比较模糊,我看了一下没怎么看懂,就直接取找了一下源码,看了一下源码瞬间就秒懂了。

首先将原图划分为NxN个patch,然后遍历每个patch,遍历每个patch时,将行patch的该位置减k到该位置所有的patch shuffle,然后将列patch做同样的操作,直到遍历完所有像素。细节见代码,毕竟talk is cheap:

def swap(img, crop):
    def crop_image(image, cropnum):
        width, high = image.size
        crop_x = [int((width / cropnum[0]) * i) for i in range(cropnum[0] + 1)]
        crop_y = [int((high / cropnum[1]) * i) for i in range(cropnum[1] + 1)]
        im_list = []
        for j in range(len(crop_y) - 1):
            for i in range(len(crop_x) - 1):
                im_list.append(image.crop((crop_x[i], crop_y[j], min(crop_x[i + 1], width), min(crop_y[j + 1], high))))
        return im_list

    widthcut, highcut = img.size
    img = img.crop((10, 10, widthcut-10, highcut-10))
    images = crop_image(img, crop)
    pro = 5
    if pro >= 5:          
        tmpx = []
        tmpy = []
        count_x = 0
        count_y = 0
        k = 1
        RAN = 2
        for i in range(crop[1] * crop[0]):
            tmpx.append(images[i])
            count_x += 1
            if len(tmpx) >= k:
                tmp = tmpx[count_x - RAN:count_x]
                random.shuffle(tmp)
                tmpx[count_x - RAN:count_x] = tmp
            if count_x == crop[0]:
                tmpy.append(tmpx)
                count_x = 0
                count_y += 1
                tmpx = []
            if len(tmpy) >= k:
                tmp2 = tmpy[count_y - RAN:count_y]
                random.shuffle(tmp2)
                tmpy[count_y - RAN:count_y] = tmp2
        random_im = []
        for line in tmpy:
            random_im.extend(line)
        
        # random.shuffle(images)
        width, high = img.size
        iw = int(width / crop[0])
        ih = int(high / crop[1])
        toImage = Image.new('RGB', (iw * crop[0], ih * crop[1]))
        x = 0
        y = 0
        for i in random_im:
            i = i.resize((iw, ih), Image.ANTIALIAS)
            toImage.paste(i, (x * iw, y * ih))
            x += 1
            if x == crop[0]:
                x = 0
                y += 1
    else:
        toImage = img
    toImage = toImage.resize((widthcut, highcut))
    return toImage

Adversarial Learning

如上所说,对抗训练的目的是为了给网络加一层约束,即让网络学习到的特征能够过滤掉shuffle带来的noise,从而学习到对细粒度分类更加有帮助的特征。

因此只需要一个二分类判别器来判断图像是否真实即可,其loss可写为:
\[ L_{adv} = -\sum_{I \in \mathcal{I}} \textbf{d}_I \cdot log(D(I)) + (1-\textbf{d}_I)\cdot log(D(\phi(I))) \]
其中\(I\)表述输入图像,D为二分类神经网络,\(\textbf{d}_I\)表示gt的one-hot表示,\(\phi\)表示RCM操作。

上式相当于是两个二分类交叉熵的和,因为公式是对正例和负例同时做的(因为可以直接得到两个),所以求和很好理解。

Construction Learning

与上面对抗训练一样,重建支路带来的梯度回传同样可以指导网络学习更加有用的feature,这在很多paper都用到了,讨论班的时候也听学长们讲过。

该部分的设计是使得网络学习将结构后的feature map映射到原来没有RCM的位置,也就是patch的下标。因此,重构网络的输出必须是\(2 \cdot N \cdot N\)的,文章的做法是先接一个1×1 conv将结构网络输出的feature map 转化为channel为2的feature map,然后relu+pooling,使得网络的输出刚好为\(2\cdot N \cdot N\)的。

其Loss定义为:
\[ L_{loc} = \sum_{I \in \mathcal{I}} \sum_{i=1}^N \sum_{j=1}^N |M_{\sigma(i,j)}(\phi(I)) - [i,j]^T| + |M_{(i,j)}(I) - [i,j]^T| \]
其中,\(\sigma(i,j)\)表示(i,j)经过RCM变换后的位置M表述重构网络,\(M_{(i,j)}\)表示取重构网络输出结果的第(i,j)个向量,因为该处的feature对应的应该是未经过RCM的原图的(i,j)位置,所以两者的target都是(i,j).

最终联合训练的loss为:
\[ L = \alpha L_{cls} + \beta L_{adv} + \gamma L_{loc} \]

Coding

本文开源在:https://github.com/JDAI-CV/DCL

你可能感兴趣的:([论文理解] Destruction and Construction Learning for Fine-grained Image Recognition)