【多模态】19、RegionCLIP | 基于 Region 来实现视觉语言模型预训练-Toy模板网

这篇具有很好参考价值的文章主要介绍了【多模态】19、RegionCLIP | 基于 Region 来实现视觉语言模型预训练。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

【多模态】19、RegionCLIP | 基于 Region 来实现视觉语言模型预训练,多模态,语言模型,人工智能,自然语言处理

论文： RegionCLIP: Region-based Language-Image Pretraining

代码：https://github.com/microsoft/RegionCLIP

出处：CVPR2022 Oral | 微软 | 张鹏川

一、背景

近期，视觉-语言模型取得了很大的突破，如 CLIP 和 ALIGN，这些模型使用了极大的图文对儿来学习图像和文本的匹配，并且在很多无手工标签的情况下也取得了很好的效果。

为了探索这种思路能否在 region-caption 的情况下起作用，作者基于预训练好的 CLIP 模型构建了一个 R-CNN 形式的目标检测器。

效果和现状：

在 paperwithcode 开放词汇目标检测 COCO(Novel) 排名第 4 名
代码相对较完善，容易入手

【多模态】19、RegionCLIP | 基于 Region 来实现视觉语言模型预训练,多模态,语言模型,人工智能,自然语言处理

主要思路：

先从输入图像中抠出候选区域
然后使用 CLIP 模型将抠出的区域和 text embedding 进行匹配

【多模态】19、RegionCLIP | 基于 Region 来实现视觉语言模型预训练,多模态,语言模型,人工智能,自然语言处理

图 1 a-b 展示了在 LVIS 上的结果，当使用 proposal 作为输入时，CLIP 的得分无法代码定位的质量，可以看出不准的框得分为 65%，较准的框得分为 55%。
图 1b 中对比了使用 gt 框作为输入，CLIP 在 LVIS 框上的分类准确率只有 19%
所以，直接将预训练好的 CLIP 拿来用于对 region 的分类不太适合

作者想探索一下这种差别来源于哪里？

首先可以想到，CLIP 模型的训练是使用整个 image 作为输入的，使用的是 image-level 的文本描述来训练的，所以，模型学习到的是整张图的特征
所以这种模型无法将文本概念和图像中的区域联系起来

本文如何解决 image 和 region 之间的差距：

作者通过使用 vision-language 预训练的模型来探索如何学习 region 的表达
主要思想是在预训练过程中，将 image region 和 text token 进行对齐

面临的问题：

image-text pairs 中不包含 image region 和 text token 的对齐关系
整张图的文本描述是不全的，也就是图中的有些目标是没有体现在文本描述中的

二、方法

如何预训练：

由于 CLIP 缺少 region 层面的训练，所以 RegionCLIP 构建了一些 region 的伪标签来和 image-text 一起预训练
伪标签如何构建：从网络数据中收集图像描述语句，然后使用 NLP parser 来提取出有效的目标词汇，构建词汇池，然后将词汇池的每个词都填入 prompt 模版（a photo of kite），并且对每个词汇对应的 prompt 模版使用 CLIP 的 text encoder 来得到语义特征，所有的 region concept 都能够使用 semantic embedding 来表示了
构建的 region 伪标签如何和 region 进行对应：使用 CLIP 的 visual encoder $V_t$ 来提取每个 region 的 visual feature，计算其和词汇池中的向量的距离，得分最大的向量就被分配给该 region 了，就能得到每个 region 对应的伪标签了，之后用于 pretraining
联合预训练：将 images-concept 和 region-concept 的数据联合进行预训练，训练的时候会同时使用对比学习 loss 和蒸馏 loss
- region-text 对比学习 loss：计算学生模型学习的 region-text pairs 的相似度
- 蒸馏 loss：计算教师模型和学生模型得到的 region-text 的 matching score
- image-text 对比学习 loss：从网络得到的 image-text pairs

如何 zero-shot 推理：

经过预训练的 visual encoder 可以直接用于 region reasoning，也就是对区域内容的识别（注意是没有定位能力的呦！）
例如使用预训练好的 RPN 网络来提取目标，就可以预测目标的类别
而且，作者也将 RPN objectness score 和 category confidence score 做了平均来作为最终得分，这样能够提升效果

如何迁移到目标检测：

使用上面预训练好的 visual encoder 来初始化目标检测器的 visual backbone
使用预训练好的 RPN 来进行目标的定位
使用人工标注的目标检测数据集中的基础类别（base）来训练 visual backbone，我们可以看到这里 visual backbone 是会训练的，那么怎么保证它预训练时候学习到的权重不被忘记呢，这里借用了 focal scaling 的思想，也就是对参与训练的 base 类别设置一定的权重，缓解模型对之前学习到的 object concept 忘记的情况（尤其是 base 类别很少的时候，模型很容易过拟合，对新类的识别产生影响）
然后通过使用预训练得到的 visual backbone 来提取 proposal 的视觉特征并且和目标的类别进行匹配

【多模态】19、RegionCLIP | 基于 Region 来实现视觉语言模型预训练,多模态,语言模型,人工智能,自然语言处理

本文的目标是学习一个区域级别的视觉-语义空间，能够覆盖足够丰富的目标词汇且用于开放词汇目标检测

假设文本描述 t 能够描述图像 I 中的区域 r
在视觉-语义空间，从 r 中抽取到的 visual region representation 能够和 text representation 很好的匹配上

总体框架图如图 2：

$V_t$ ：CLIP 的 visual encoder， $L$ ：CLIP 的 language encoder
$V$ ：本文需要训练的 visual encoder，使用 $V_t$ 进行初始化，
我们的目标是训练一个 visual encoder $V$ 类实现对 image region 的编码，并且将这些编码和 language encoder 输出的语言编码对齐
为了克服缺少大规模 region 描述的问题，如图 2 底部，作者构建了一个目标词汇池，通过将词汇填入 prompt 来构建 region 的描述，并且借助 teacher encoder $V_t$ 来将这些描述和使用图像定位网络得到的图像区域进行对齐
通过使用这些创建的 region-text pairs，visual encoder $V$ 就需要通过对比学习和词汇整理来学习将这些 pairs 对齐

2.1 Region-based Language-Image Pretraining

1、Visual region representation

可以使用现有的目标定位器（如 RPN）或密集滑动窗口来进行图像区域的生成

作者使用经过人工标注 bbox 训练过的 RPN 来生成，这里不对 bbox 的类别进行区分

对于一个输入 batch，使用 RPN 产生 N 个 image regions
使用 visual encoder $V$ 进行视觉特征抽取，并使用 RoIAlign 来 pooling，且 $V$ 的权重是使用 teacher $V_t$ 的来进行初始化的

2、Semantic region representation

一个单个的图像通常会包含丰富的语义信息，多个不同类别的目标，且人工标注这么大规模的数据也不太可行

所以，作者首先构建了一个大的词汇池，来尽可能的覆盖所有区域词汇，如图 2 所示，而且建立的词汇池是从文本语料库中解析得来的

有了词汇池后，按照如下的方式来构建每个区域的语义表达：

第一步，将 concept 填入 prompt 模版（a photo of a kite）
第二步，使用预训练的 language encoder L 来得到语义特征表达
第三步，使用语义编码就能表达每个区域词汇的特征表达 ${l_j\}_{j=1,...,C}$

3、visual-semantic alignment for regions

① 如何对齐 region-text pairs：使用 CLIP 来构建伪标签，即使用 teacher model CLIP 预测的得分最大的 concept 作为该区域的描述

作者借用 teacher visual encoder 来建立 region-text 之间的关系，这里的 text 表示语义编码，区域 $r_i$ 的 visual representation $v_i^t$ 是从 teacher visual encoder $V_t$ 中抽取的
然后，计算 $v_i^t$ 和 ${l_j\}$ 的匹配得分，得分最高的就和区域进行关联起来，然后就能得到每个区域的伪标签： ${v_i, l_m\}$

② 如何预训练：

同时使用来自网络的 region-text pairs 和 image-text pairs
region-text pairs 就是通过 ① 的方法来创建的
拿到上述 region-text pairs ${v_i, l_m\}$ ，使用对比学习 loss 和蒸馏 loss 来训练 visual decoder，总共包含 3 部分
- region-text 的对比学习 loss 如下， $\tau$ 是预定义的温度参数， $N_{ri}$ 是 region $r_i$ 的 negative textual samples，也就是在一个 batch 中和 region $r_i$ 不匹配但和其他区域匹配的
- 除了对比学习 loss 以外，还有考虑每个图像区域的知识蒸馏，蒸馏 loss 如下， $q_i^t$ 是从 teacher model 得到的 soft target， $q_i$ 是 student model 得到的预测
- image-text 的对比学习 loss $L_{cntrst-img}$ 可以从 region level 扩展而来，也就是特殊情况，即 ① 一个 box 覆盖了整张图，② 文本描述来源于网络，③ negative samples 是从其他图像而来的文本描述

③ 零样本推理

预训练之后，训练得到的 visual encoder 可以直接用于 region reasoning 任务，比如从 RPN 获得区域，从训练的 visual encoder 得到该区域的视觉表达，然后和文本词汇表达进行匹配，得到相似度最高的文本

实验证明使用 RPN score 能够提升 zero-shot 推理的效果，所以作者也使用了 RPN objectness score + category confidence score 的均值来作为最终的得分，用于匹配。

2.2 目标检测的迁移学习

预训练中，本文的 visual encoder 是从 teacher model 提供的 region-text alignment 中学习的，不需要人为一些操作，所以也会有一个噪声，当引入更强的监督信号（如人为标注 label）时，可以进一步 fine-tuning visual encoder，如图 2

如何将预训练网络迁移到目标检测器呢，作者通过初始化目标检测器的 visual backbone 来实现，先使用现有的 RPN 网络来进行目标区域的定位，然后将区域和文本匹配

开放词汇目标检测：

对基础类别，使用类似于 focal loss 的加权权重 $(1-p^b) \gamma$ ， $p^b$ 是预测的概率， $\gamma$ 是超参数，该加权权重能缓解模型对预训练中的知识的遗忘，尤其是当数据集中有很少的基础类时（如 coco），作者猜测如果基础类别很少，模型可能会对基础类别过拟合，对新类的泛化能力会降低
对背景类别，作者使用固定的 all-zero 编码方式，并且使用预定义的权重

三、效果

3.1 数据集

预训练时，作者使用：

来自于 Conceptual Caption dataset (CC3M) 的 image-text pairs，包括 300 万来自网络的 pairs
COCO Caption（COCO Cap），包含 118k images，每个 images 约有 5 个人工标注的 captions
作者从 COCO/CC3M 中抽取了目标词汇，过滤掉了出现频次小于 100 的词汇，得到了 4764/6790 个词汇

为了开放词汇目标检测的迁移学习，作者使用 COCO 数据集和 LVIS 数据集的基础类来训练。

COCO：48 个基础类，17 个新类
LVIS：866 个基础类，337 个新类

作者使用目标检测标准测评：AP 和 AP50

COCO：使用 AP50 测评新类、基础类、所有类
LVIS：rare 类也就是 novel 类，即测评新类的 AP (APr)、基础类的 AP (APc/APf)、所有类的 AP (mAP)

3.2 实现细节

1、预训练

teacher model 和 student model ：都是预训练的 CLIP（ResNet50）
RPN：使用 LVIS 的基础类别训练
默认模型：使用 CC3M 数据集，使用从 COCO Cap 解析出来的词汇
优化器： SGD、batch = 96、learning rate = 0.002, maximum iteration = 600k、 100 regions per image.

2、目标检测迁移

使用 detectron2 基于 Faster RCNN [42] with ResNet50-C4 结构作为检测器
RPN：使用目标数据集的基础类别来训练
SGD：batch=16，initial learning = 0.002，1x schedule
focal scaling： $\gamma=0.5$

3、目标检测零样本推理

RPN：使用 LVIS 的基础类别训练得到的 RPN
NMS：threshold=0.9
$\tau=0.01$

3.3 结果

RegionCLIP 在开放词汇检测的 novel 类上的效果达到了 39.3AP

【多模态】19、RegionCLIP | 基于 Region 来实现视觉语言模型预训练,多模态,语言模型,人工智能,自然语言处理

四、代码

环境安装：

https://github.com/microsoft/RegionCLIP/blob/zero-shot/docs/INSTALL.md

数据准备：

https://github.com/microsoft/RegionCLIP/blob/zero-shot/datasets/README.md

1、zero-shot 测试（使用 gt 框，主要测试的是对 region 的识别能力）

# RN50x4, GT, COCO
python3 ./tools/train_net.py \
--eval-only  \
--num-gpus 1 \
--config-file ./configs/COCO-InstanceSegmentation/CLIP_fast_rcnn_R_50_C4_ovd_zsinf.yaml \
MODEL.WEIGHTS ./pretrained_ckpt/regionclip/regionclip_pretrained-cc_rn50x4.pth \
MODEL.CLIP.TEXT_EMB_PATH ./pretrained_ckpt/concept_emb/coco_65_cls_emb_rn50x4.pth \
MODEL.CLIP.CROP_REGION_TYPE GT \
MODEL.CLIP.MULTIPLY_RPN_SCORE False \
MODEL.CLIP.TEXT_EMB_DIM 640 \
MODEL.RESNETS.DEPTH 200 \
MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION 18 \

Evaluation results for bbox: 
|   AP   |  AP50  |  AP75  |  APs   |  APm   |  APl   |
|:------:|:------:|:------:|:------:|:------:|:------:|
| 64.946 | 65.451 | 64.903 | 52.922 | 71.390 | 70.545 |
Per-category bbox AP: 
| category   | AP     | category   | AP     | category     | AP     |
|:-----------|:-------|:-----------|:-------|:-------------|:-------|
| person     | 73.463 | bicycle    | 79.673 | car          | 84.925 |
| motorcycle | 66.633 | airplane   | 97.827 | bus          | 85.852 |
| train      | 89.867 | truck      | 51.154 | boat         | 82.183 |
| bench      | 42.759 | bird       | 73.442 | cat          | 76.972 |
| dog        | 73.316 | horse      | 83.049 | sheep        | 90.901 |
| cow        | 81.264 | elephant   | 93.201 | bear         | 84.405 |
| zebra      | 95.208 | giraffe    | 95.268 | backpack     | 46.059 |
| umbrella   | 71.930 | handbag    | 33.646 | tie          | 80.318 |
| suitcase   | 65.223 | frisbee    | 24.740 | skis         | 38.639 |
| snowboard  | 14.005 | kite       | 59.969 | skateboard   | 53.792 |
| surfboard  | 44.970 | bottle     | 76.109 | cup          | 64.295 |
| fork       | 53.513 | knife      | 19.605 | spoon        | 30.435 |
| bowl       | 52.905 | banana     | 81.173 | apple        | 67.057 |
| sandwich   | 72.380 | orange     | 68.320 | broccoli     | 91.791 |
| carrot     | 80.076 | pizza      | 87.340 | donut        | 78.442 |
| cake       | 73.971 | chair      | 68.974 | couch        | 57.402 |
| bed        | 56.792 | toilet     | 74.647 | tv           | 65.258 |
| laptop     | 66.412 | mouse      | 23.762 | remote       | 19.321 |
| keyboard   | 50.904 | microwave  | 66.310 | oven         | 52.184 |
| toaster    | 29.439 | sink       | 60.021 | refrigerator | 60.273 |
| book       | 84.199 | clock      | 91.148 | vase         | 62.869 |
| scissors   | 40.443 | toothbrush | 59.085 |              |        |

2、fine-tuning COCO 48 个基础类别的代码

数据进入模型的位置：RegionCLIP/detectron2/engine/train_loop.py line273

# data 
[{'file_name': 'datasets/coco/train2017/000000526362.jpg', 'height': 403, 'width': 640, 'image_id': 526362, 'image': tensor([[[67, 70, 74,  ..., 56, 56, 56],
         [68, 71, 74,  ..., 57, 57, 57],
         [70, 72, 74,  ..., 59, 59, 59],
         ...,
         [69, 71, 75,  ..., 88, 83, 80],
         [67, 69, 72,  ..., 82, 77, 74],
         [66, 68, 70,  ..., 79, 74, 71]],

        [[49, 50, 52,  ..., 56, 54, 53],
         [51, 52, 54,  ..., 56, 54, 52],
         [54, 55, 56,  ..., 57, 53, 50],
         ...,
         [66, 69, 74,  ..., 80, 74, 71],
         [63, 65, 69,  ..., 74, 68, 65],
         [61, 63, 66,  ..., 70, 64, 61]],

        [[47, 51, 58,  ..., 31, 34, 36],
         [48, 51, 57,  ..., 33, 37, 40],
         [50, 52, 55,  ..., 37, 43, 46],
         ...,
         [61, 64, 70,  ..., 81, 75, 72],
         [59, 61, 66,  ..., 75, 69, 66],
         [57, 59, 63,  ..., 71, 65, 62]]], dtype=torch.uint8), 'instances': Instances(num_instances=11, image_height=736, image_width=1169, fields=[gt_boxes: Boxes(tensor([[125.1378, 305.5587, 361.0018, 481.5047],
        [558.6907, 319.8769, 689.9657, 380.5649],
        [550.3981, 297.8700, 613.7433, 347.7828],
        [681.0156, 162.0844, 896.0568, 673.1569],
        [104.9726, 271.2607, 152.7920, 347.9289],
        [ 53.9933, 272.5574, 119.6947, 468.4102],
        [809.8613, 271.8634, 870.2109, 377.9351],
        [683.9929, 315.2929, 733.6754, 439.1162],
        [456.3666, 289.1585, 561.3574, 395.3945],
        [350.7730, 279.0408, 427.6165, 470.8756],
        [  6.0459, 486.8557, 146.3076, 728.2017]])), gt_classes: tensor([ 2,  2,  2,  0,  0,  0, 15, 15,  5,  0,  2])])}]

模型：

CLIPFastRCNN(
  (offline_backbone): ResNet(
    (stem): BasicStem(
      (conv1): Conv2d(
        3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False
        (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
      )
    )
    (res2): Sequential(
      (0): BottleneckBlock(
        (shortcut): Conv2d(
          64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv1): Conv2d(
          64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
        )
        (conv2): Conv2d(
          64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
        )
        (conv3): Conv2d(
          64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
      )
      (1): BottleneckBlock(
        (conv1): Conv2d(
          256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
        )
        (conv2): Conv2d(
          64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
        )
        (conv3): Conv2d(
          64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
      )
      (2): BottleneckBlock(
        (conv1): Conv2d(
          256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
        )
        (conv2): Conv2d(
          64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)
        )
        (conv3): Conv2d(
          64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
      )
    )
    (res3): Sequential(
      (0): BottleneckBlock(
        (shortcut): Conv2d(
          256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False
          (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
        )
        (conv1): Conv2d(
          256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False
          (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
        )
        (conv2): Conv2d(
          128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
        )
        (conv3): Conv2d(
          128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
        )
      )
      (1): BottleneckBlock(
        (conv1): Conv2d(
          512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
        )
        (conv2): Conv2d(
          128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
        )
        (conv3): Conv2d(
          128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
        )
      )
      (2): BottleneckBlock(
        (conv1): Conv2d(
          512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
        )
        (conv2): Conv2d(
          128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
        )
        (conv3): Conv2d(
          128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
        )
      )
      (3): BottleneckBlock(
        (conv1): Conv2d(
          512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
        )
        (conv2): Conv2d(
          128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05)
        )
        (conv3): Conv2d(
          128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)
        )
      )
    )
    (res4): Sequential(
      (0): BottleneckBlock(
        (shortcut): Conv2d(
          512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False
          (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
        )
        (conv1): Conv2d(
          512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv2): Conv2d(
          256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv3): Conv2d(
          256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
        )
      )
      (1): BottleneckBlock(
        (conv1): Conv2d(
          1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv2): Conv2d(
          256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv3): Conv2d(
          256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
        )
      )
      (2): BottleneckBlock(
        (conv1): Conv2d(
          1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv2): Conv2d(
          256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv3): Conv2d(
          256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
        )
      )
      (3): BottleneckBlock(
        (conv1): Conv2d(
          1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv2): Conv2d(
          256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv3): Conv2d(
          256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
        )
      )
      (4): BottleneckBlock(
        (conv1): Conv2d(
          1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv2): Conv2d(
          256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv3): Conv2d(
          256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
        )
      )
      (5): BottleneckBlock(
        (conv1): Conv2d(
          1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv2): Conv2d(
          256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)
        )
        (conv3): Conv2d(
          256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False
          (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
        )
      )
    )
  )
  (backbone): ModifiedResNet(
    (conv1): Conv2d(3, 40, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=40, eps=1e-05)
    (conv2): Conv2d(40, 40, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): FrozenBatchNorm2d(num_features=40, eps=1e-05)
    (conv3): Conv2d(40, 80, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=80, eps=1e-05)
    (avgpool): AvgPool2d(kernel_size=2, stride=2, padding=0)
    (relu): ReLU(inplace=True)
    (layer1): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(80, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=80, eps=1e-05)
        (conv2): Conv2d(80, 80, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=80, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(80, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (-1): AvgPool2d(kernel_size=1, stride=1, padding=0)
          (0): Conv2d(80, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(320, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=80, eps=1e-05)
        (conv2): Conv2d(80, 80, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=80, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(80, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(320, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=80, eps=1e-05)
        (conv2): Conv2d(80, 80, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=80, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(80, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (3): Bottleneck(
        (conv1): Conv2d(320, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=80, eps=1e-05)
        (conv2): Conv2d(80, 80, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=80, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(80, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
    )
    (layer2): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(320, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (conv2): Conv2d(160, 160, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (avgpool): AvgPool2d(kernel_size=2, stride=2, padding=0)
        (conv3): Conv2d(160, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (-1): AvgPool2d(kernel_size=2, stride=2, padding=0)
          (0): Conv2d(320, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(640, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (conv2): Conv2d(160, 160, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(160, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(640, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (conv2): Conv2d(160, 160, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(160, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (3): Bottleneck(
        (conv1): Conv2d(640, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (conv2): Conv2d(160, 160, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(160, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (4): Bottleneck(
        (conv1): Conv2d(640, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (conv2): Conv2d(160, 160, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(160, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (5): Bottleneck(
        (conv1): Conv2d(640, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (conv2): Conv2d(160, 160, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=160, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(160, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
    )
    (layer3): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(640, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): AvgPool2d(kernel_size=2, stride=2, padding=0)
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (-1): AvgPool2d(kernel_size=2, stride=2, padding=0)
          (0): Conv2d(640, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (3): Bottleneck(
        (conv1): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (4): Bottleneck(
        (conv1): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (5): Bottleneck(
        (conv1): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (6): Bottleneck(
        (conv1): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (7): Bottleneck(
        (conv1): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (8): Bottleneck(
        (conv1): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (9): Bottleneck(
        (conv1): Conv2d(1280, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (conv2): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=320, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=1280, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
    )
    (layer4): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(1280, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (conv2): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (avgpool): AvgPool2d(kernel_size=2, stride=2, padding=0)
        (conv3): Conv2d(640, 2560, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=2560, eps=1e-05)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (-1): AvgPool2d(kernel_size=2, stride=2, padding=0)
          (0): Conv2d(1280, 2560, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): FrozenBatchNorm2d(num_features=2560, eps=1e-05)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(2560, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (conv2): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(640, 2560, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=2560, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(2560, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (conv2): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(640, 2560, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=2560, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (3): Bottleneck(
        (conv1): Conv2d(2560, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (conv2): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(640, 2560, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=2560, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (4): Bottleneck(
        (conv1): Conv2d(2560, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (conv2): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(640, 2560, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=2560, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
      (5): Bottleneck(
        (conv1): Conv2d(2560, 640, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (conv2): Conv2d(640, 640, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): FrozenBatchNorm2d(num_features=640, eps=1e-05)
        (avgpool): Identity()
        (conv3): Conv2d(640, 2560, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): FrozenBatchNorm2d(num_features=2560, eps=1e-05)
        (relu): ReLU(inplace=True)
      )
    )
    (attnpool): AttentionPool2d(
      (k_proj): Linear(in_features=2560, out_features=2560, bias=True)
      (q_proj): Linear(in_features=2560, out_features=2560, bias=True)
      (v_proj): Linear(in_features=2560, out_features=2560, bias=True)
      (c_proj): Linear(in_features=2560, out_features=640, bias=True)
    )
  )
  (offline_proposal_generator): RPN(
    (rpn_head): StandardRPNHead(
      (conv): Conv2d(
        1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)
        (activation): ReLU()
      )
      (objectness_logits): Conv2d(1024, 15, kernel_size=(1, 1), stride=(1, 1))
      (anchor_deltas): Conv2d(1024, 60, kernel_size=(1, 1), stride=(1, 1))
    )
    (anchor_generator): DefaultAnchorGenerator(
      (cell_anchors): BufferList()
    )
  )
  (roi_heads): CLIPRes5ROIHeads(
    (pooler): ROIPooler(
      (level_poolers): ModuleList(
        (0): ROIAlign(output_size=(18, 18), spatial_scale=0.0625, sampling_ratio=0, aligned=True)
      )
    )
    (box_predictor): FastRCNNOutputLayers(
      (cls_score): Linear(in_features=640, out_features=48, bias=False)
      (cls_bg_score): Linear(in_features=640, out_features=1, bias=False)
      (test_cls_score): Linear(in_features=640, out_features=65, bias=False)
      (bbox_pred): Linear(in_features=640, out_features=4, bias=True)
    )
  )
)

第一步：生成 proposals 1000 个
- 如果使用 GT 的话就直接使用标注的框，如图使用 RPN 的话，就使用现有的 RPN 网络来生成，生成的话就是，先对图像进行归一化，然后使用 offline_backbone 来进行特征提取，不进行最后类别特征的提取，输出的特征为 [1,1024, 46, 74]（一般情况提取类别的话通道数要变成类别的数量）
- 对得到的特征使用现有的 RPN 网络来提取 proposals，先生成 anchors，然后使用 rpn_head 来得到 objectness 和 anchor_deltas，得到每个 proposal 的前景得分和相对 anchor 的偏移，且 RPN 不参与训练的情况下是不用反传 loss 的
第二步：对输入图像使用 backbone （ResNet50）提取特征，得到 [1, 1280, 46, 73]，这里的 backbone 是使用 CLIP visual encoder 的权重来初始化的，会参与训练，对输入的 text 使用 CLIP 的 text encoder 来编码，且不参与训练。
第三步：对 RPN 预测的 proposal 分配标签，并剔除不满足 IoU 阈值的 proposals，分配的标准是依据 IoU 来将其分配到对应的 gt 上，gt 的类别就是该 proposal 的类别，分配标签后的 proposal 数量一般会比 1000 少，比如 512 个，然后会包含 box 坐标、objectness 得分、对应的类别 cls、gt box。假设有 48 类，那么背景类别的标签就是 48
第四步：根据 proposal 的 box 坐标来提取特征图中对应位置的特征，并且使用 RoIAlign 的方法，将输出特征图大小统一为 18x18，得到特征 [512, 1280, 18, 18] 的特征，512 表示有 512 个 proposals，然后使用 backbone_res5 对 proposal 的特征进行处理，得到 [512, 2560, 9, 9] 特征
第五步：对得到的 proposal 特征进行 attention，得到 [512, 640] 特征，每个 proposal 特征使用 640 维的向量表示（或者进行取平均来表示每个 proposal 的特征）
第六步：使用 attention 后的特征来得到每个 proposal 的 score 和 regress delta，
- 先对 [512, 640] 的特征进行 normalize，计算 CLIP embedding 和图像 embedding 的矩阵相乘结果，作为 cls_score，得到结果 [512, 48]，这里的 48 为 COCO 的 48 个基础类别，并且将 background score 设置为全零 [512, 1]，cat 后得到最终的 score [512, 49]，并且给 score 除以温度参数来作为最终的结果
- 然后使用线性映射将 proposal_delta 的预测映射到 [512, 4]
第七步：计算 loss，使用 focal loss 来计算分类 loss，即计算每个 proposal 的类别和真实 gt 类别的 loss，前景类别权重为 1 ，背景类别权重为 0.2，使用 L1 loss （或 GIoU loss ）来计算回归 loss，回归 loss 只计算前景 proposal 的文章来源地址https://www.toymoban.com/news/detail-612839.html