上一节提到这个图

这一次主要是model部分
我们通过tokenizer得到了

我们可以通过from_pretrained加载预训练好的模型，把tokenizer送入到model里面

还有好多模型可以使用

查看模型，automodel的架构如下:

DistilBertModel(
  (embeddings): Embeddings(
    (word_embeddings): Embedding(30522, 768, padding_idx=0)
    (position_embeddings): Embedding(512, 768)
    (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
    (dropout): Dropout(p=0.1, inplace=False)
  )
  (transformer): Transformer(
    (layer): ModuleList(
      (0): TransformerBlock(
        (attention): MultiHeadSelfAttention(
          (dropout): Dropout(p=0.1, inplace=False)
          (q_lin): Linear(in_features=768, out_features=768, bias=True)
          (k_lin): Linear(in_features=768, out_features=768, bias=True)
          (v_lin): Linear(in_features=768, out_features=768, bias=True)
          (out_lin): Linear(in_features=768, out_features=768, bias=True)
        )
        (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        (ffn): FFN(
          (dropout): Dropout(p=0.1, inplace=False)
          (lin1): Linear(in_features=768, out_features=3072, bias=True)
          (lin2): Linear(in_features=3072, out_features=768, bias=True)
        )
        (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
      )
      (1): TransformerBlock(
        (attention): MultiHeadSelfAttention(
          (dropout): Dropout(p=0.1, inplace=False)
          (q_lin): Linear(in_features=768, out_features=768, bias=True)
          (k_lin): Linear(in_features=768, out_features=768, bias=True)
          (v_lin): Linear(in_features=768, out_features=768, bias=True)
          (out_lin): Linear(in_features=768, out_features=768, bias=True)
        )
        (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        (ffn): FFN(
          (dropout): Dropout(p=0.1, inplace=False)
          (lin1): Linear(in_features=768, out_features=3072, bias=True)
          (lin2): Linear(in_features=3072, out_features=768, bias=True)
        )
        (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
      )
      (2): TransformerBlock(
        (attention): MultiHeadSelfAttention(
          (dropout): Dropout(p=0.1, inplace=False)
          (q_lin): Linear(in_features=768, out_features=768, bias=True)
          (k_lin): Linear(in_features=768, out_features=768, bias=True)
          (v_lin): Linear(in_features=768, out_features=768, bias=True)
          (out_lin): Linear(in_features=768, out_features=768, bias=True)
        )
        (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        (ffn): FFN(
          (dropout): Dropout(p=0.1, inplace=False)
          (lin1): Linear(in_features=768, out_features=3072, bias=True)
          (lin2): Linear(in_features=3072, out_features=768, bias=True)
        )
        (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
      )
      (3): TransformerBlock(
        (attention): MultiHeadSelfAttention(
          (dropout): Dropout(p=0.1, inplace=False)
          (q_lin): Linear(in_features=768, out_features=768, bias=True)
          (k_lin): Linear(in_features=768, out_features=768, bias=True)
          (v_lin): Linear(in_features=768, out_features=768, bias=True)
          (out_lin): Linear(in_features=768, out_features=768, bias=True)
        )
        (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        (ffn): FFN(
          (dropout): Dropout(p=0.1, inplace=False)
          (lin1): Linear(in_features=768, out_features=3072, bias=True)
          (lin2): Linear(in_features=3072, out_features=768, bias=True)
        )
        (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
      )
      (4): TransformerBlock(
        (attention): MultiHeadSelfAttention(
          (dropout): Dropout(p=0.1, inplace=False)
          (q_lin): Linear(in_features=768, out_features=768, bias=True)
          (k_lin): Linear(in_features=768, out_features=768, bias=True)
          (v_lin): Linear(in_features=768, out_features=768, bias=True)
          (out_lin): Linear(in_features=768, out_features=768, bias=True)
        )
        (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        (ffn): FFN(
          (dropout): Dropout(p=0.1, inplace=False)
          (lin1): Linear(in_features=768, out_features=3072, bias=True)
          (lin2): Linear(in_features=3072, out_features=768, bias=True)
        )
        (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
      )
      (5): TransformerBlock(
        (attention): MultiHeadSelfAttention(
          (dropout): Dropout(p=0.1, inplace=False)
          (q_lin): Linear(in_features=768, out_features=768, bias=True)
          (k_lin): Linear(in_features=768, out_features=768, bias=True)
          (v_lin): Linear(in_features=768, out_features=768, bias=True)
          (out_lin): Linear(in_features=768, out_features=768, bias=True)
        )
        (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        (ffn): FFN(
          (dropout): Dropout(p=0.1, inplace=False)
          (lin1): Linear(in_features=768, out_features=3072, bias=True)
          (lin2): Linear(in_features=3072, out_features=768, bias=True)
        )
        (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
      )
    )
  )
)

而AutoModelForSequenceClassification的架构如下

DistilBertForSequenceClassification(
  (distilbert): DistilBertModel(
    (embeddings): Embeddings(
      (word_embeddings): Embedding(30522, 768, padding_idx=0)
      (position_embeddings): Embedding(512, 768)
      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
      (dropout): Dropout(p=0.1, inplace=False)
    )
    (transformer): Transformer(
      (layer): ModuleList(
        (0): TransformerBlock(
          (attention): MultiHeadSelfAttention(
            (dropout): Dropout(p=0.1, inplace=False)
            (q_lin): Linear(in_features=768, out_features=768, bias=True)
            (k_lin): Linear(in_features=768, out_features=768, bias=True)
            (v_lin): Linear(in_features=768, out_features=768, bias=True)
            (out_lin): Linear(in_features=768, out_features=768, bias=True)
          )
          (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
          (ffn): FFN(
            (dropout): Dropout(p=0.1, inplace=False)
            (lin1): Linear(in_features=768, out_features=3072, bias=True)
            (lin2): Linear(in_features=3072, out_features=768, bias=True)
          )
          (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        )
        (1): TransformerBlock(
          (attention): MultiHeadSelfAttention(
            (dropout): Dropout(p=0.1, inplace=False)
            (q_lin): Linear(in_features=768, out_features=768, bias=True)
            (k_lin): Linear(in_features=768, out_features=768, bias=True)
            (v_lin): Linear(in_features=768, out_features=768, bias=True)
            (out_lin): Linear(in_features=768, out_features=768, bias=True)
          )
          (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
          (ffn): FFN(
            (dropout): Dropout(p=0.1, inplace=False)
            (lin1): Linear(in_features=768, out_features=3072, bias=True)
            (lin2): Linear(in_features=3072, out_features=768, bias=True)
          )
          (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        )
        (2): TransformerBlock(
          (attention): MultiHeadSelfAttention(
            (dropout): Dropout(p=0.1, inplace=False)
            (q_lin): Linear(in_features=768, out_features=768, bias=True)
            (k_lin): Linear(in_features=768, out_features=768, bias=True)
            (v_lin): Linear(in_features=768, out_features=768, bias=True)
            (out_lin): Linear(in_features=768, out_features=768, bias=True)
          )
          (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
          (ffn): FFN(
            (dropout): Dropout(p=0.1, inplace=False)
            (lin1): Linear(in_features=768, out_features=3072, bias=True)
            (lin2): Linear(in_features=3072, out_features=768, bias=True)
          )
          (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        )
        (3): TransformerBlock(
          (attention): MultiHeadSelfAttention(
            (dropout): Dropout(p=0.1, inplace=False)
            (q_lin): Linear(in_features=768, out_features=768, bias=True)
            (k_lin): Linear(in_features=768, out_features=768, bias=True)
            (v_lin): Linear(in_features=768, out_features=768, bias=True)
            (out_lin): Linear(in_features=768, out_features=768, bias=True)
          )
          (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
          (ffn): FFN(
            (dropout): Dropout(p=0.1, inplace=False)
            (lin1): Linear(in_features=768, out_features=3072, bias=True)
            (lin2): Linear(in_features=3072, out_features=768, bias=True)
          )
          (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        )
        (4): TransformerBlock(
          (attention): MultiHeadSelfAttention(
            (dropout): Dropout(p=0.1, inplace=False)
            (q_lin): Linear(in_features=768, out_features=768, bias=True)
            (k_lin): Linear(in_features=768, out_features=768, bias=True)
            (v_lin): Linear(in_features=768, out_features=768, bias=True)
            (out_lin): Linear(in_features=768, out_features=768, bias=True)
          )
          (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
          (ffn): FFN(
            (dropout): Dropout(p=0.1, inplace=False)
            (lin1): Linear(in_features=768, out_features=3072, bias=True)
            (lin2): Linear(in_features=3072, out_features=768, bias=True)
          )
          (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        )
        (5): TransformerBlock(
          (attention): MultiHeadSelfAttention(
            (dropout): Dropout(p=0.1, inplace=False)
            (q_lin): Linear(in_features=768, out_features=768, bias=True)
            (k_lin): Linear(in_features=768, out_features=768, bias=True)
            (v_lin): Linear(in_features=768, out_features=768, bias=True)
            (out_lin): Linear(in_features=768, out_features=768, bias=True)
          )
          (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
          (ffn): FFN(
            (dropout): Dropout(p=0.1, inplace=False)
            (lin1): Linear(in_features=768, out_features=3072, bias=True)
            (lin2): Linear(in_features=3072, out_features=768, bias=True)
          )
          (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
        )
      )
    )
  )
  (pre_classifier): Linear(in_features=768, out_features=768, bias=True)
  (classifier): Linear(in_features=768, out_features=2, bias=True)
  (dropout): Dropout(p=0.2, inplace=False)
)

区别就在于最后三层
我们可以使用save_pretrained保存模型
保存了两个文件


两次结果是一样的

参考：
https://huggingface.co/course/chapter2/3?fw=pt

pigz支持多线程并行处理
之前处理好的数据大约50G左右，记得用zip压缩差不多要1个小时，用pigz不到10分钟，8w条数据，大文件压缩速度效果挺明显的

sudo apt-get update -y
sudo apt-get install -y pigz

用coco数据集测试一下

经过测试，
pigz 大约1分钟压缩 1.3g左右
zip 大约1分钟压缩 1.1g左右
因为colab这个cpu只有2个线程，而推荐的是8个线程起步，所以速度差距没有那么明显

参考：
https://wangchujiang.com/linux-command/c/pigz.html
https://zoomadmin.com/HowToInstall/UbuntuPackage/pigz

一、使用块和线程建立矩阵索引
多线程的优点就是每个线程处理不同的数据计算，那么怎么分配好每个线程处理不同的数据，而不至于
多个不同的线程处理同一个数据，或者避免不同的线程没有组织的乱访问内存。下图说明了块和线程索
引、矩阵坐标以及线性全局内存索引之间的对应关系：


这样我们就得到了每个线程的唯一标号，并且在运行时kernel是可以访问这个标号的。为了让不同线程
处理不同的数据，CUDA常用的做法是让不同的线程对应不同的数据，也就是用线程的全局标号对应不
同组的数据。
设备内存或者主机内存都是线性存在的，比如一个二维矩阵 (8×6)(8×6)，存储在内存中是这样的：

#include <cuda_runtime.h>
#include <stdio.h>
#include "dependence.h"

__global__ void printThreadIndex(float *A,const int nx,const int ny)
{
  int ix=threadIdx.x+blockIdx.x*blockDim.x;
  int iy=threadIdx.y+blockIdx.y*blockDim.y;
  unsigned int idx=iy*nx+ix;
  printf("thread_id(%d,%d) block_id(%d,%d) coordinate(%d,%d)"
          "global index %2d ival %2d\n",threadIdx.x,threadIdx.y,
          blockIdx.x,blockIdx.y,ix,iy,idx,A[idx]);
}
int main(int argc,char** argv)
{
  initDevice(0);
  int nx=8,ny=6;
  int nxy=nx*ny;
  int nBytes=nxy*sizeof(float);

  //Malloc
  float* A_host=(float*)malloc(nBytes);
  initialData(A_host,nxy);
  printMatrix(A_host,nx,ny);

  //cudaMalloc
  float *A_dev=NULL;
  CHECK(cudaMalloc((void**)&A_dev,nBytes));

  cudaMemcpy(A_dev,A_host,nBytes,cudaMemcpyHostToDevice);

  dim3 block(4,2);
  dim3 grid((nx-1)/block.x+1,(ny-1)/block.y+1);

  printThreadIndex<<<grid,block>>>(A_dev,nx,ny);

  CHECK(cudaDeviceSynchronize());
  cudaFree(A_dev);
  free(A_host);

  cudaDeviceReset();
  return 0;
}

这段代码输出了一组我们随机生成的矩阵，并且核函数打印自己的线程标号，输出结果：

未完待续
参考：
https://face2ai.com/program-blog/

像情感分析，实际的流程是这样

对于Tokenizer，做的工作是这样

对于tokenizer，由3种方式，分别是word-based,character-based,subword tokenization
第一个是这样的

第二个是这样的

最后一个是这样的

像那些预训练模型，用的tokenizer如下：

然后涉及到关于tokenizer中encoding和decoding的部分
encoding涉及到两个函数

decoding涉及到一个函数

参考：
https://huggingface.co/course/chapter2/1?fw=pt

现在的多模态预训练模型受bert的启发，从单模态扩展到多模态，总的来说，现在多模态预训练模型分别两种，双流模型和单流模型。
双流模型，顾名思义，就是两个模态先做单独的交互，然后两个模态再交互，介绍一篇典型的双流模型，LXMERT: Learning Cross-Modality Encoder Representations from Transformers。

看架构其实很简单，这是2019年的emnlp，考虑的东西没有那么多。
输入分为两部分，文本就是用bert分词，因为没有和图像联合起来输入，不用考虑segment embeddings。

图像就是通过BUTD提取，考虑区域特征和位置特征

encoder就是self_attention和cross_attention，正如上面的图所示
输出分为3部分，其中多模态的表示为CLS

预训练任务一共有5个
Masked
Cross-Modality LM,RoI-Feature Regression,DetectedLabel Classification,Cross-Modality Matching,Image Question Answering (QA)
使用图像和文本对来训练
微调的任务都是多模态理解任务，这是后来者改进的地方

参考文献：
https://arxiv.org/abs/1908.07490

Stanza: A Python NLP Library for Many Human Languages
是斯坦福大学nlp组的一个nlp包
之前为了构造图里面的边，使用的这个包

对于我自己而言，我要提取dependency parsing来建图
代码参考如下：

参考链接：
https://stanfordnlp.github.io/stanza/
https://github.com/stanfordnlp/stanza

看的有个组 最近连续发了image caption的文章 aaai2021两篇 cvpr2021两篇
之前那篇看过了，这次介绍剩下的那篇aaai2021
总的来说，aaai的质量确实比cvpr差不少

看的这一篇就没啥东西，主要是会讲故事，会包装，aaai2021文章都没和CVPR2020去比较
Improving Image Captioning by Leveraging Intra- and Inter-layer Global
Representation in Transformer Network AAAI2021

模型架构如下：

用我的理解来看，就在在标准的transformer架构上，加了一个全局表示

经过encoder编码后，这样会有若干个全局表示，用LSTM得到最终表示

然后decoder部分，把全局表示拼接起来，self-attention加cross-attention就完成了

没什么有价值的insight

参考文献：
https://arxiv.org/abs/2012.07061

Sparsely-gated Mixture of Experts networks (MoEs) have demonstrated excellent scalability in Natural Language Processing. In Computer Vision, however, almost all performant networks are “dense”, that is, every input is processed by every parameter. We present a Vision MoE (V-MoE), a sparse version of the Vision Transformer, that is scalable and competitive with the largest dense networks. When applied to image recognition, V-MoE matches the performance of state-of-the-art networks, while requiring as little as half of the compute at inference time. Further, we propose an extension to the routing algorithm that can prioritize subsets of each input across the entire batch, leading to adaptive per-image compute. This allows V-MoE to trade-off performance and compute smoothly at test-time. Finally, we demonstrate the potential of V-MoE to scale vision models, and train a 15B parameter model that attains 90.35% on ImageNet.
https://arxiv.org/abs/2106.05974
我是做nlp，有没有小伙伴科普一下，像那些经典Resnet，ResXnet模型等等的参数都有多大呀

之前看了一篇关于多模态预训练模型和视觉transfomer相关的
这是前置条件，因此来看看ViT是什么东西
An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale ICLR2021
本来以为很复杂，其实你要之前做NLP，就很容易理解
模型架构如下：

总的来说，按照我自己的理解
图像的输入 一般都是 b 3 h w ，而文本而言，维度是b length dim，比图像少一个维度，因此
需要将图像的维度降一维，这就是patch projection

爱因斯坦求和之前学张量网络也用过，这里就不细说了
因为这篇文章是做分类，借鉴bert的cls思想，在前面一个加了一个cls
其实类似于faster-rcnn，所以输入的是图片，和我之前想的不太一样

参考文献：
https://arxiv.org/pdf/2010.11929.pdf
https://zhuanlan.zhihu.com/p/308301901

transformers 是 hugging face的库，包含很多预训练模型
本节介绍安装方式及pipeLine 以及相关模型
官方推荐两种安装方式
!pip install transformers
!pip install transformers[sentencepiece]
将任务分为如下种类

通过pipeline，我们可以做情感分析

当前pipeline可以做的任务有

做零次分类

做命名实体识别

还有很多任务可以做，不一一列举了

最后模型可分为这几类

参考：
https://huggingface.co/course/chapter0?fw=pt 0章和第1章

这次介绍一篇比较新的文章

RSTNet: Captioning with Adaptive Attention on Visual and Non-Visual Words CVPR2021
总的来说，贡献点有两个，对我而言，有启发的是后者
模型结果如下：

第一次看没看懂，之前把bert忘的差不多了

昨天又仔细看了一遍才看懂

说白了，第二点，还是对qkv的改进

把从h_t预测变成h_t去自主选择视觉还是文本

核心代码如下：

这一点看懂就好了，希望实验效果好一点

参考文献：
https://openaccess.thecvf.com/content/CVPR2021/html/Zhang_RSTNet_Captioning_With_Adaptive_Attention_on_Visual_and_Non-Visual_Words_CVPR_2021_paper.html

Hierarchical Attention Network for Image Captioning
AAAI 2019
由于这篇文章被其他问题提到，顺便看一看吧，看看有没有启发
模型架构如下：

首先它引入了4个图像特征

这个patch特征 我一开始以为是VIT那种， 其实就是grid feature

整体架构如下：

但我看了半天没找到V_g怎么来的，可能是时间紧迫吧，今天要把代码改完

然后就是attetion，但现在看，这个attention也不是qkv那种形式，交互比较简单

还提到一点，使用gate来平衡不同feature的特征
CVPR2021有篇工作的重点就是这个，选text feature还是image feature，那个当时没看懂，下次写吧
先留个坑吧，以后再补

参考文献：
https://ojs.aaai.org//index.php/AAAI/article/view/4924

Similarity Reasoning and Filtration for Image-Text Matching AAAI2021
这一篇的质量还可以，动机把相似度从标量转化为向量，从而继续建图

模型分为两个模型，一个是 Similarity Graph Reasoning (SGR) ，另一个是The Similarity Attention Filtration (SAF)

模型结构如下：

总的来说，一个是对图的边进行更新，一个是对节点进行更新（这个比较新颖）

后者这个公式比较少见

最后联合训练，推断时取两个模块的平均值

参考文献：
https://arxiv.org/abs/2101.01368

看的有个组 最近连续发了image caption的文章 aaai2021两篇 cvpr2021两篇
之前那篇看过了，这次介绍剩下的那篇aaai2021
总的来说，aaai的质量确实比cvpr差不少

看的这一篇就没啥东西，主要是会讲故事，会包装，aaai2021文章都没和CVPR2020去比较
Improving Image Captioning by Leveraging Intra- and Inter-layer Global
Representation in Transformer Network AAAI2021

模型架构如下：

用我的理解来看，就在在标准的transformer架构上，加了一个全局表示

经过encoder编码后，这样会有若干个全局表示，用LSTM得到最终表示

然后decoder部分，把全局表示拼接起来，self-attention加cross-attention就完成了

没什么有价值的insight

参考文献：
https://arxiv.org/abs/2012.07061

哭了，iccv 2021有一篇就是类似的套路，换到别的任务上了

Dynamic Modality Interaction Modeling for Image-Text Retrieval
是SIGIR2021 最佳学生论文
不得不承认，写的层次比之前看的确实要高一级，和Vit有一拼

文章首先总结了以往模型的策略，大体分为三种，Intra-modal Interaction，Cross-modal Interaction，Hybrid-modal Interaction。

动机在于这样模型就固定下来，不同的输出会经过同样处理，即使是简单的，也可能会经历复杂的架构，基于此，提出了动态的架构，可以自由选择。

为了解决这些问题，本文提出了一种基于路由机制的新型模态交互建模网络，这是第一个面向图像-文本检索的统一动态多模态交互框架。具体来说，坐着首先设计了四种类型的单元格作为基本单元来探索不同层次的模态交互，然后以密集的策略将它们连接起来以构建路由空间。

本文的模型首先分别使用从底至顶的注意力机制抽取图像特征并选择得分靠前的区域，另一方面使用 BERT+CNN 抽取文本特征。在此基础上设计了四种交互方式：

Rectified Identity Cell：通过 Relu 保留有区别的线索；
Intra-Modal Reasoning Cell：通过注意力机制建模模态内的交互特征；
Global-Local Guidance Cell：通过一种模态指导另一种模态的注意力交互；
Cross-Modal Refinement Cell：两种模态互相交互的特征。

具体的模型图如下：

在此基础上，本文使用了动态路由的机制选择交互的方式，在训练的阶段，除了原本的损失函数以外，还加入了路径正则的机制，使得相同的语义信息应该选择相同的路径。

不得出承认，这种思路确实很细，Dynamic Network像我这种根本就不知道，太难了

因为还没开源代码，只能看看这个4个部分，有没有什么启发，insight确实比我高一个层次

参考文献：
https://dl.acm.org/doi/abs/10.1145/3404835.3462829
https://mp.weixin.qq.com/s/13y4x0H6kzNUawe202-BXg

Check It Again: Progressive Visual Question Answering
via Visual Entailment 被录用在ACL2021上

这篇任务是做VQA CP 的，总的来说，正如论文摘要写的那样，分为两个部分select-and-rerank。

模型架构如下：

which consists of a Candidate Answer Selecting module and an Answer Re-ranking module.包含这两个模块。

前者使用现有的VQA模型生成答案，再取前topN个
后者把候选答案和问题组成caption，假设图片是正确的，这样就组成了图像-描述对，然后看成Visual Entailment任务，推断描述和图像是否符合，这里借助 LXMERT来判断

因为我也不是搞这个方向的，只大体看一下思路。

这个跟我看的视觉对话naacl2020的一篇文章思路感觉很相似，视觉对话有两个重要的指标，那篇是先训练一个NDCG指标，也和topN差不多，然后再在那个基础上训练，就类似于rerank。

参考文献：
https://arxiv.org/abs/2106.04605

Graph Structured Network for Image-Text Matching CVPR2022
这一篇还有点启发
一开始看introduction的时候，感觉还有点复杂，还涉及到属性，关系之类的东西，我以为还要自己去生成，后来仔细一看，都是一类东西，这表示他们存在边，这样的做法，我在ACL2020一篇文章也见过，但那篇没有开源代码，这篇有代码

模型架构如下：

他是用的CoreNLP做的，我之前是用的别的提取的
总的来说，是先建图，然后先图与图之间传播，达到对齐的效果，或者说叫做cross-attention或者inter，然后再图内传播，我一直觉得图神经网络和transformers是差不多的

那个inter部分，或者论文中Node-level Matching我还需要看一下代码，暂时没看懂

对了，其中还提到了稀疏图和稠密图，这个我还要仔细看一下，可能会对我有些启发

参考文献：
https://arxiv.org/abs/2004.00277
这是2020年那篇ACL，希望对别人有所启发吧https://www.aclweb.org/anthology/2020.acl-main.642.pdf

本次介绍一个多模态预训练模型
在视觉transformer上改进的VIT
ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision 被录用在ICML2021上

先阐述一下4种不同类型的Vision-and-Language Pretraining(VLP)，然后归纳2种模态相互作用方式和3种visual embedding方式，最后讲一下ViLT的设计思路。

上图是4种不同类型的VLP模型示意图。其中每个矩形的高表示相对计算量大小，VE、TE和MI分别是visual embedding、text embedding和modality interaction的简写。

作者提出这4种类型的主要依据有两点：

1.在参数或者计算上，两种模态是否保持平衡。

2.在网络深层中，两种模态是否相互作用。

VSE、VSE++和SCAN属于(a)类型。对图像和文本独立使用encoder，图像的更重，文本的更轻，使用简单的点积或者浅层attention层来表示两种模态特征的相似性。

CLIP属于(b)类型。每个模态单独使用重的transformer encoder，使用池化后的图像特征点积计算特征相似性。

ViLBERT、UNTER和Pixel-BERT属于(c0类型。这些方法使用深层transformer进行交互作用，但是由于VE仍然使用重的卷积网络进行特征抽取，导致计算量依然很大。

作者提出的ViLT属于(d)类型。ViLT是首个将VE设计的如TE一样轻量的方法，该方法的主要计算量都集中在模态交互上。

Modality Interaction Schema
模态交互部分可以分成两种方式：一种是single-stream(如BERT和UNITER)，另一种是dual-stream(如ViLBERT和LXMERT)。其中single-stream是对图像和文本concate然后进行交互操作，而dual-stream是不对图像和文本concate然后进行交互操作。ViLT延用single-stream的交互方式，因为dual-stream会引入额外的计算量。

现有的VLP模型的text embedding基本上都使用类BERT结构，但是visual embedding存在着差异。在大多数情况下，visual embedding是现有VLP模型的瓶颈。visual embedding的方法总共有三大类，其中region feature方法通常采用Faster R-CNN二阶段检测器提取region的特征，grid feature方法直接使用CNN提取grid的特征，patch projection方法将输入图片切片投影提取特征。ViLT是首个使用patch projection来做visual embedding的方法。

作者提出的ViLT可以认为是目前最简单的多模态Transformer方法。ViLT使用预训练的ViT来初始化交互的transformer，这样就可以直接利用交互层来处理视觉特征，不需要额外增加一个视觉encoder。

文本特征输入部分，将文本看成一个词序列，通过word embedding matrix转化成word embedding，然后和position embedding进行相加，最后和modal-type embedding进行concate。

图像特征输入部分，将图像切块看成一个图像块序列，通过linear projection转化成visual embedding，然后和postion embedding进行相加，最后和modal-type embedding进行concate。

其中word embedding和visual embedding通过可学习的modal-type embedding标志位来区分，其中0标志位表示word embedding部分，1标志位表示visual embedding部分。

wrod embedding和visual embedding分别都嵌入了一个额外的可学习[class] embedding，方便和下游任务对接。

Pretraining Objectives

ViLT预训练的优化目标有两个：一个是image text matching(ITM)，另一个是masked language modeling(MLM)。

ImageText Matching：随机以0.5的概率将文本对应的图片替换成不同的图片，然后对文本标志位对应输出使用一个线性的ITM head将输出feature映射成一个二值logits，用来判断图像文本是否匹配。另外ViLT还设计了一个word patch alignment (WPA)来计算teextual subset和visual subset的对齐分数。

Masked Language Modeling：MLM的目标是通过文本的上下文信息去预测masked的文本tokens。随机以0.15的概率mask掉tokens，然后文本输出接两层MLP与车mask掉的tokens。

Whole Word Masking：另外ViLT还使用了whole word masking技巧。whole word masking是将连续的子词tokens进行mask的技巧，避免了只通过单词上下文进行预测。比如将“giraffe”词tokenized成3个部分[“gi”, “##raf”, “##fe”]，可以mask成[“gi”, “[MASK]”, “##fe”]，模型会通过mask的上下文信息[“gi”，“##fe”]来预测mask的“##raf”，就会导致不利用图像信息。

参考文献：
https://zhuanlan.zhihu.com/p/369733979
https://arxiv.org/pdf/2102.03334.pdf

之前看了一篇关于多模态预训练模型和视觉transfomer相关的
这是前置条件，因此来看看ViT是什么东西
An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale ICLR2021
本来以为很复杂，其实你要之前做NLP，就很容易理解
模型架构如下：

总的来说，按照我自己的理解
图像的输入 一般都是 b 3 h w ，而文本而言，维度是b length dim，比图像少一个维度，因此
需要将图像的维度降一维，这就是patch projection

爱因斯坦求和之前学张量网络也用过，这里就不细说了
因为这篇文章是做分类，借鉴bert的cls思想，在前面一个加了一个cls
其实类似于faster-rcnn，所以输入的是图片，和我之前想的不太一样

参考文献：
https://arxiv.org/pdf/2010.11929.pdf
https://zhuanlan.zhihu.com/p/308301901