# Transformer 为什么使用多头注意力，而不是单头？

在现代深度学习中，Transformer 模型的多头注意力（Multi-Head Attention）机制被证明是自然语言处理和其他领域中极其强大的工具。一个常见的问题是：**为什么 Transformer 使用多头注意力，而不是简单地使用一个头的注意力？** 本文将从公式推导和代码实现的角度进行详细且专业的讲解。





## 1. 多头注意力的直觉

在单头注意力中，我们可以通过自注意力机制计算每个输入元素之间的关系，从而捕捉到全局的依赖关系。但是，单头注意力存在局限性，它仅能够在单个表示空间中进行线性变换，从而可能无法充分表示输入数据的不同特征关系。

**多头注意力**通过在不同的子空间中进行注意力计算，从而获得多个表示。这样可以捕捉到输入的不同方面的特征，使得模型的表示能力大大增强。换句话说，多头注意力提供了一种并行计算的方式，通过在多个空间中独立捕捉不同的上下文信息，从而使得 Transformer 的表达能力更加丰富。

## 2. 多头注意力的公式推导

首先，我们回顾一下**单头注意力**的计算过程。假设输入矩阵为 $X \in \mathbb{R}^{n \times d}$，其中 $n$ 是序列长度，$d$ 是特征维度。注意力计算的步骤如下：

1. 通过线性变换得到 Query, Key, Value 矩阵：
   $$
   Q = XW^Q, \quad K = XW^K, \quad V = XW^V
   $$
   其中，$W^Q, W^K, W^V \in \mathbb{R}^{d \times d_k}$ 是可学习的参数矩阵。

2. 计算注意力权重：
   $$
   A = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)
   $$

3. 计算输出：
   $$
   H = AV
   $$

在**多头注意力**中，我们将输入 $X$ 变换为多个不同的 Query, Key, Value，分别进行注意力计算。假设有 $h$ 个头，每个头的维度为 $d_k$，则计算过程如下：

1. 对每个头 $i$，分别计算 Query, Key, Value：
   $$
   Q_i = XW_i^Q, \quad K_i = XW_i^K, \quad V_i = XW_i^V
   $$

2. 对每个头 $i$，计算注意力权重和输出：
   $$
   A_i = \text{softmax}\left(\frac{Q_iK_i^T}{\sqrt{d_k}}\right), \quad H_i = A_iV_i
   $$

3. 将所有头的输出拼接在一起，并通过线性变换得到最终的输出：
   $$
   H_{\text{multi}} = [H_1, H_2, \ldots, H_h]W^O
   $$
   其中，$W^O \in \mathbb{R}^{hd_k \times d}$ 是可学习的参数矩阵。

通过上述步骤，多头注意力能够在多个子空间中独立捕捉输入的不同特征关系，使得模型能够更好地理解复杂的上下文依赖。

## 3. 代码实现

以下是多头注意力的代码实现，基于 PyTorch：

```python
import torch
import torch.nn as nn
import torch.nn.functional as F

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        
        self.d_k = d_model // num_heads
        self.num_heads = num_heads
        
        # 定义线性变换矩阵
        self.w_q = nn.Linear(d_model, d_model)
        self.w_k = nn.Linear(d_model, d_model)
        self.w_v = nn.Linear(d_model, d_model)
        self.w_o = nn.Linear(d_model, d_model)
        
    def forward(self, x):
        batch_size = x.size(0)
        
        # 线性变换并分割成多头
        q = self.w_q(x).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        k = self.w_k(x).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        v = self.w_v(x).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        
        # 计算注意力得分
        scores = torch.matmul(q, k.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.d_k, dtype=torch.float32))
        attn = F.softmax(scores, dim=-1)
        
        # 计算注意力输出
        h = torch.matmul(attn, v)
        h = h.transpose(1, 2).contiguous().view(batch_size, -1, self.num_heads * self.d_k)
        
        # 最后线性变换
        output = self.w_o(h)
        return output
```

## 4. 多头注意力的优势

1. **捕捉不同特征**：多头注意力可以在不同的子空间中进行注意力计算，从而能够捕捉输入序列的不同特征关系。

2. **提升模型的稳定性**：单头注意力可能会陷入某些特定的注意力模式，而多头注意力通过多个头的并行计算，可以提高模型的稳定性，减少对某些特征的过度依赖。

3. **增强表达能力**：通过在多个子空间中计算注意力，多头注意力能够增强模型的表达能力，使得模型在面对复杂任务时具有更好的表现。

## 5. 总结

多头注意力机制是 Transformer 中的关键组件，其通过在多个子空间中并行地计算注意力，提升了模型的特征提取能力和表达能力。这使得 Transformer 在自然语言处理等任务中取得了非常优异的效果。

使用多头注意力的主要原因在于它能够捕捉输入数据的不同方面，从而提供更加全面的特征表示。如果仅使用一个头，模型将难以充分表示复杂的上下文依赖关系，进而影响整体性能。通过本文的公式推导和代码实现，希望能够帮助读者更好地理解多头注意力的工作原理及其优势。

【知识点】transformer为什么使用多头注意力机制？为什么不使用一个头

提示词：推荐博客的软文撰写者





```
# Role: 推荐博客的软文撰写者

## Profile
- author: LangGPT
- version: 1.0
- language: 中文
- description: 以用户给入的目标博客文章为基础，帮助用户撰写新的推荐博客内容，以软文的形式推广目标博客的知识点，并适当覆盖相关知识，避免触发审核不通过。

## Skills
1. 熟悉软文写作技巧，能够自然融入推广内容。
2. 擅长总结和覆盖博客中的核心知识点。
3. 能够保持内容的中立性和信息性，符合审核要求。
4. 写作要自然流畅，带有目标博客的一些结构内容，将目标博客的知识点都简要提到。

## Goals
1. 以推荐博客为主要目的，突出其内容的实用性和价值。
2. 将博客的核心知识点巧妙嵌入，以吸引读者继续阅读目标博客。
3. 避免明显的推广语言，确保通过审核。


## Rules
1. 使用中立、客观的语气描述博客内容。
2. 在文字中适当融入目标博客的链接，以引导读者深入阅读。文章末尾放入"目标博客文章的访问链接"。
3. 不要直接引用或复制目标博客内容，而是总结关键知识点。

## Workflows
1. 分析目标博客的主题内容，抓取主要知识点。
2. 将核心信息融入推荐博客内容，以便读者获得有价值的信息。
3. 检查文章的语气和内容，确保符合软广的审核标准。

## 开始工作
目标博客文章的访问链接：https://www.dong-blog.fun/post/1746

目标博客文章的内容：


如何理解多模态模型Qwen2-VL中的MIN_PIXELS和MAX_PIXELS
在多模态模型Qwen2-VL中，MIN_PIXELS 和 MAX_PIXELS 的设定决定了图像输入的最小和最大像素限制。这些设定帮助模型在保证图像质量的前提下，控制计算成本和资源消耗。本文将结合源码详细介绍这些变量的意义及其实现细节。完整代码可以在 Qwen2-VL的GitHub仓库 中找到。

MIN_PIXELS：4 * 28 * 28 的含义
在代码中，MIN_PIXELS = 4 * 28 * 28 定义了图像输入的最小像素要求。这种设定在图像处理中具有重要作用：

基础单元与 Transformer Patch 的关联：

多模态模型通常会将图像划分为小块（patch）来提取特征。在Qwen2-VL中，使用28x28作为基本单元，确保图像大小可以与patch大小灵活适配。通过使用4倍的基础单元，模型可以将最小分辨率控制在3136个像素。
通过 MIN_PIXELS = 4 * 28 * 28 的设定，模型保证了即使输入图像较小，经过划分后至少能够生成四个基础patch，从而满足基本的输入需求。
在 smart_resize 函数中，当图像的总像素低于 MIN_PIXELS 时，代码通过放大图像尺寸，确保图像在划分为patch后具有足够的信息量。例如，若图像分辨率过低，会按比例增大，直到达到 MIN_PIXELS 为止：
python
if h_bar * w_bar < min_pixels:
    beta = math.sqrt(min_pixels / (height * width))
    h_bar = ceil_by_factor(height * beta, factor)
    w_bar = ceil_by_factor(width * beta, factor)
维持信息量的充足性：

通过设置 MIN_PIXELS，模型能保证即使是低分辨率图像也能提供足够的视觉信息。这对于在模型中提取出有效的特征至关重要，确保每个patch都能携带有效数据。
MAX_PIXELS：16384 * 28 * 28 的上限
在代码中，MAX_PIXELS = 16384 * 28 * 28 定义了图像输入的最大像素限制，约束了图像的最高分辨率，防止系统在高分辨率图像处理中出现性能问题。16384 是128乘以128的大小。

控制图像缩放以避免计算负担：

smart_resize 函数中，当图像分辨率超过 MAX_PIXELS 时，系统会自动缩小图像尺寸，以符合这一上限：
python
if h_bar * w_bar > max_pixels:
    beta = math.sqrt((height * width) / max_pixels)
    h_bar = floor_by_factor(height / beta, factor)
    w_bar = floor_by_factor(width / beta, factor)
这样一来，图像即使超过了设定的最大分辨率，也会按比例缩小以满足限制。这种设置可以避免在处理大图像时出现内存溢出或速度下降的问题。
确保大型图像任务的兼容性：

MAX_PIXELS 的设定上限允许约1280x1280的高分辨率图像处理，使得模型适配于如高清影像分析、复杂视觉任务等应用场景。
整体图像处理流程
当图像输入模型时，smart_resize 函数会自动调整图像尺寸，使其满足MIN_PIXELS和MAX_PIXELS的限制条件，同时保持图像的纵横比接近原始比例。函数首先通过 round_by_factor 函数将图像尺寸调整为28的倍数。然后，它根据实际像素数与 MIN_PIXELS 和 MAX_PIXELS 的对比，按需缩放或放大图像。

总结
通过代码中的 MIN_PIXELS 和 MAX_PIXELS 设定，Qwen2-VL能够适应不同分辨率的图像输入，同时控制资源消耗。这种设定使得图像处理更加灵活和高效，既能满足低分辨率图像的信息量需求，又能避免超高分辨率图像对系统的负担。有关更多细节，请访问 GitHub 仓库 查看源码。


```

提示词：推荐博客的软文撰写者

## 如何理解多模态模型Qwen2-VL中的MIN_PIXELS和MAX_PIXELS

在多模态模型Qwen2-VL中，`MIN_PIXELS` 和 `MAX_PIXELS` 的设定决定了图像输入的最小和最大像素限制。这些设定帮助模型在保证图像质量的前提下，控制计算成本和资源消耗。本文将结合源码详细介绍这些变量的意义及其实现细节。完整代码可以在 [Qwen2-VL的GitHub仓库](https://github.com/QwenLM/Qwen2-VL/blob/main/qwen-vl-utils/src/qwen_vl_utils/vision_process.py) 中找到。





### MIN_PIXELS：`4 * 28 * 28` 的含义

在代码中，`MIN_PIXELS = 4 * 28 * 28` 定义了图像输入的最小像素要求。这种设定在图像处理中具有重要作用：

1. **基础单元与 Transformer Patch 的关联**：
   - 多模态模型通常会将图像划分为小块（patch）来提取特征。在Qwen2-VL中，使用28x28作为基本单元，确保图像大小可以与patch大小灵活适配。通过使用4倍的基础单元，模型可以将最小分辨率控制在3136个像素。
   - 通过 MIN_PIXELS = 4 * 28 * 28 的设定，模型保证了即使输入图像较小，经过划分后至少能够生成四个基础patch，从而满足基本的输入需求。
   - 在 `smart_resize` 函数中，当图像的总像素低于 `MIN_PIXELS` 时，代码通过放大图像尺寸，确保图像在划分为patch后具有足够的信息量。例如，若图像分辨率过低，会按比例增大，直到达到 `MIN_PIXELS` 为止：

   ```python
   if h_bar * w_bar < min_pixels:
       beta = math.sqrt(min_pixels / (height * width))
       h_bar = ceil_by_factor(height * beta, factor)
       w_bar = ceil_by_factor(width * beta, factor)
   ```

2. **维持信息量的充足性**：
   - 通过设置 `MIN_PIXELS`，模型能保证即使是低分辨率图像也能提供足够的视觉信息。这对于在模型中提取出有效的特征至关重要，确保每个patch都能携带有效数据。

### MAX_PIXELS：`16384 * 28 * 28` 的上限

在代码中，`MAX_PIXELS = 16384 * 28 * 28` 定义了图像输入的最大像素限制，约束了图像的最高分辨率，防止系统在高分辨率图像处理中出现性能问题。16384 是128乘以128的大小。

1. **控制图像缩放以避免计算负担**：
   - `smart_resize` 函数中，当图像分辨率超过 `MAX_PIXELS` 时，系统会自动缩小图像尺寸，以符合这一上限：

   ```python
   if h_bar * w_bar > max_pixels:
       beta = math.sqrt((height * width) / max_pixels)
       h_bar = floor_by_factor(height / beta, factor)
       w_bar = floor_by_factor(width / beta, factor)
   ```

   - 这样一来，图像即使超过了设定的最大分辨率，也会按比例缩小以满足限制。这种设置可以避免在处理大图像时出现内存溢出或速度下降的问题。

2. **确保大型图像任务的兼容性**：
   - `MAX_PIXELS` 的设定上限允许约1280x1280的高分辨率图像处理，使得模型适配于如高清影像分析、复杂视觉任务等应用场景。

### 整体图像处理流程

当图像输入模型时，`smart_resize` 函数会自动调整图像尺寸，使其满足`MIN_PIXELS`和`MAX_PIXELS`的限制条件，同时保持图像的纵横比接近原始比例。函数首先通过 `round_by_factor` 函数将图像尺寸调整为28的倍数。然后，它根据实际像素数与 `MIN_PIXELS` 和 `MAX_PIXELS` 的对比，按需缩放或放大图像。

### 总结

通过代码中的 `MIN_PIXELS` 和 `MAX_PIXELS` 设定，Qwen2-VL能够适应不同分辨率的图像输入，同时控制资源消耗。这种设定使得图像处理更加灵活和高效，既能满足低分辨率图像的信息量需求，又能避免超高分辨率图像对系统的负担。有关更多细节，请访问 [GitHub 仓库](https://github.com/QwenLM/Qwen2-VL/blob/main/qwen-vl-utils/src/qwen_vl_utils/vision_process.py) 查看源码。

如何理解多模态模型Qwen2-VL中的MIN_PIXELS和MAX_PIXELS

## 1.（）是计算机检索系统中存储的信息源，按一定的方式组织并储存，借助于检索系统随时为用户提供服务。

答案：数据库

## 2. 字段是数据库中最基本的（），如篇名字段、作者字段、文摘字段、主题字段等。

答案：数据单元

##  3. 不同字段的集合构成记录，每条记录所包含的字段并不一定完全相同，但一个数据库内的记录往往含有相同的字段。

答案：正确

## 4. 文档由若干相同类型或不同类型的记录组成，一个数据库由若干个文档组成。

答案：正确

## 5. 受控词指末经规范化处理的自然语言词汇，又称自由词，包括自然语言和关键词。

答案：错误

## 6. 检索语言是应文献信息的加工、存储和检索的共同需要而编制的专门语言，是用来描述文献的内容特征和外表特征以及表达情报提问的一种人工语言，表达文献外部特征的检索语言有

- 出版时间
- 主题词
- 题名
- 专利号

答案：出版时间、题名、专利号

解析：

文献外部特征的检索语言主要是指对文献的篇名（即文献题名）、作者姓名、出版者、报告号、专利号等内容的检索。

主题词：这是描述文献内容特征的关键词或受控词，用来标示文献的主题或内容，不属于外部特征，而是内容特征。


## 7. 表达文献内容特征的检索语言有（）【多选题】

- 作者
- 题名
- 分类号
- 摘要


答案：分类号、摘要

解析：

分类号：这是根据文献内容进行分类的标识符，用于表示文献的学科分类，反映文献的内容特征。

摘要：这是对文献内容的简要描述，直接表达文献的主题和要点，属于内容特征。

而：

作者：这是文献的书目信息，属于外部特征，与文献内容特征无关。

题名：这是文献的标题，属于外部特征。虽然题名通常与内容相关，但它并不是专门用于描述内容特征的语言。

## 8. 受控词是事先规范化的词有（）等，受控词表方案强制要求采用预先确定且经过权威认定的术语,而这些术语是由词表的设计者事先选定的。受控词的检索效率高，一旦选定适当的受控词，系统能自动检出同义词、近义词等,使检索相对容易。【多选题】

- 叙词
- 分类号
- 主题词
- 专利号

答案：叙词、主题词

解析：

- 叙词：叙词（或称为描述词）是经过规范化的词汇，常用于信息检索系统中的受控词汇表。
- 主题词：主题词也是一种受控词，用于描述文献内容的主题，是事先选定并规范化的词汇。
- 
而：

- 分类号：虽然分类号也用于文献分类和检索，但它通常不是用来描述内容的词汇，而是用来表示文献的学科分类，不属于受控词的范畴。
- 专利号：这是用于标识专利文献的独特编号，与文献内容无关，也不是受控词。

## 9. 《中国图书馆分类法》（简称中图法）是按照一定的思想观点，以______为基础，结合图书文献资料的内容和特点，分门别类组成的分类表。

答案：学科分类


解析：

《中图法》的编制始于1971年，先后出版了五版。 它按照一定的思想观点，以学科分类为基础，结合图书资料的内容和特点，分门别类组成分类表。

来源：https://lnutlib.mh.chaoxing.com/engine2/general/more?t=53378F91A67DFCF36BA998D8B8320B6DE37408456B2BD670C7852E2F504841466B1300A7097B5802


## 10. 《国际专利分类表》，简称IPC，是______等级分类体系，是帮助各国专利文献获得统一国际分类的一种工具。

答案：技术主题

## 11. 写出以下期刊的索书号和在图书馆的位置。

（1）《化学工业》（ 出版社：《化学工业》编辑部 ）索书号：**TQ-9/001**


![image.png](/static/img/f88f408eba3fbff35a57ce87a4cad2ea.image.webp)

2015年7-12卷的位置：**南九楼中文期刊密集库**


![image.png](/static/img/6396933bd0f9c508571aec9e96ba1077.image.webp)

（2）《包装与食品机械》索书号 **TS206/001**

![image.png](/static/img/210419b39145e8733297c7b04c06f9f7.image.webp)

2016年1-3卷的位置：**南九楼中文期刊密集库**

![image.png](/static/img/ccbef5019c8c3dbd7789e14b14bb9240.image.webp)

2018年1-3卷的位置：**南二楼报刊阅览室**


![image.png](/static/img/8ddaa2247f598e436e359ab0165d62d5.image.webp)


## 12. 用图书馆书目检索系统查出如下题名的中图分类号和检索结果条数（用前向匹配，资料类型: 全部，分馆名称: 所有分馆 ），再用所查出的分类号分别检索（用前向匹配）中文图书和西文图书的结果条数。

(1)题名：《有机化学》查询结果数：(992) 条.  【之前搜索是992条，图书馆加书了】


![image.png](/static/img/d27641745f931369f21f23e58a19fb2e.image.webp)


![image.png](/static/img/32248dcd47b9e46c54c5ad71f0127745.image.webp)


中图分类号：（O62）； 【老师说只用写前面的】


![image.png](/static/img/85129c7b8960add399ffffdd94b99f88.image.webp)


用所查出的分类号分别检索（用前向匹配，分馆名称: 所有分馆），中文图书查询结果数（1595）条 【图书馆加书了】


![image.png](/static/img/907e8eb6c4a3d24144eebcc111c7a4ab.image.webp)


![image.png](/static/img/c189365d36a2a39dc7165b4249d2627e.image.webp)

西文图书条查询结果数（**1326**）条


![image.png](/static/img/a11a25c9e622c05e6e8d24e73003fb0e.image.webp)


![image.png](/static/img/87827a123bc10a1427a9affbd6ab1919.image.webp)

（2）题名《物理化学》查询结果数：（**766**）条 【图书馆加书了，没加书前766条】

![image.png](/static/img/df4b516ee674bf9dc41d8c96c4bdbeba.image.webp)

中图分类号（**O64**）


![image.png](/static/img/be37840c34bf827ec4f6126054e11d25.image.webp)

用所查出的分类号分别检索（用前向匹配），中文图书查询结果数(**1780**)条.【没加书之前估计是1780条】

![image.png](/static/img/a40473e4129b3d958a621da063c6a02a.image.webp)


![image.png](/static/img/7990244471c49ca93e6efa35f51d3f3c.image.webp)


西文图书条查询结果数（**989**）条


![image.png](/static/img/3ce0010796318ac57fa89bf93b053450.image.webp)


![image.png](/static/img/f0b63e0fd44b50ea5aaa13c2929bab6d.image.webp)


## 13 用国家知识产权局专利数据库查找名称含有“污水处理反应器”的专利。

（1）检索结果得中国发明专利（**101**）条，


![image.png](/static/img/a3769e8624c90853155d1e36ba621f25.image.webp)

![image.png](/static/img/9f0fa92cd6cbfc7b3d416ba8701aaa80.image.webp)

中国实用新型专利（**130**）条，



![image.png](/static/img/bc64c4097de5c03f65eda646197cb50a.image.webp)


![image.png](/static/img/55fad78170b41b9ae15faef66e7cdf51.image.webp)



（2）把得出的检索结果（包括发明专利和实用新型专利和外观设计专利）加入分析库，点分析—高级分析—分类号分析——小组，进行统计，文献中使用频次最高的国际专利分类号（IPC）为 （）

这里有237篇专利：

![image.png](/static/img/9852b8d331f1f168e4b53e8ef1c0974d.image.webp)



![image.png](/static/img/db744eb47fe87ed1dfad502def65adca.image.webp)


C 化学；冶金

文献检索课程题目2

### 项目概述

本项目旨在构建一个基于`InternVL2-40B`模型的多模态API服务。该服务使用Docker环境，利用`lmdeploy`库进行模型部署，并通过API接口接收图像和文本输入，生成描述性文本输出。

### 环境准备

#### 相关资源链接

- [项目模型地址](https://huggingface.co/OpenGVLab/InternVL2-40B-AWQ)
- [`lmdeploy`文档](https://lmdeploy.readthedocs.io/zh-cn/stable/multi_modal/internvl.html)
- [Dockerfile](https://github.com/InternLM/lmdeploy/blob/main/docker/InternVL_Dockerfile)
- [所有InternVL2模型](https://huggingface.co/collections/OpenGVLab/internvl-20-667d3961ab5eb12c7ed1463e)





#### Docker镜像构建

使用以下`Dockerfile`构建环境，其中包含`CUDA`和依赖库配置。

```dockerfile
ARG CUDA_VERSION=cu12

FROM openmmlab/lmdeploy:latest-cu12 AS cu12
ENV CUDA_VERSION_SHORT=cu123

FROM ${CUDA_VERSION} AS final

RUN python3 -m pip install timm
RUN python3 -m pip install https://github.com/Dao-AILab/flash-attention/releases/download/v2.6.3/flash_attn-2.6.3+${CUDA_VERSION_SHORT}torch2.3cxx11abiFALSE-cp310-cp310-linux_x86_64.whl
```

构建命令：

```bash
docker build --build-arg CUDA_VERSION=cu12 -t kevinchina/deeplearning:internvl .

docker push kevinchina/deeplearning:internvl
```

### 服务启动

#### 启动容器

使用以下命令启动Docker容器：

```bash
docker run --runtime nvidia --gpus all \
    -v /root/xiedong/:/root/xiedong/ \
    -p 23333:23333 \
    --ipc=host \
    -it --rm \
    kevinchina/deeplearning:internvl bash
```

#### 启动API服务

```bash
lmdeploy serve api_server /root/xiedong/InternVL2-40B-AWQ \
    --backend turbomind --server-port 23333 --model-format awq
```

### InternVL2-40B-AWQ 测试和评估

#### 单张图像API访问

使用以下Python代码调用API，传入图像URL，并接收描述性文本输出：

```python
from openai import OpenAI

# 初始化OpenAI客户端
client = OpenAI(api_key='YOUR_API_KEY', base_url='http://0.0.0.0:23333/v1')

# 获取模型名称
# model_name = client.models.list().data[0].id
#
# print(model_name)

# 发送请求并获取响应
response = client.chat.completions.create(
    model="/root/xiedong/InternVL2-40B-AWQ",
    messages=[{
        'role': 'user',
        'content': [{
            'type': 'text',
            'text': 'Describe the image please',
        }, {
            'type': 'image_url',
            'image_url': {
                'url': '/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1024.jpeg',
            },
        }],
    }],
    temperature=0.8,
    top_p=0.8
)

# 打印返回的文本内容
print(response.choices[0].message.content)
```

#### 多次测试平均响应时间

对不同尺寸的图片进行10次请求并计算平均响应时间，代码如下：

```python
import time
from openai import OpenAI

# 初始化OpenAI客户端
client = OpenAI(api_key='YOUR_API_KEY', base_url='http://0.0.0.0:23333/v1')

# 定义图像路径
image_paths = [
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo256.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo512.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo768.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1024.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1280.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo2560.jpeg"
]

# 设置请求次数
num_requests = 10

# 存储每个图像的平均响应时间
average_speeds = {}

# 遍历每张图片
for image_path in image_paths:
    total_time = 0

    # 对每张图片执行 num_requests 次请求
    for _ in range(num_requests):
        start_time = time.time()

        # 发送请求并获取响应
        response = client.chat.completions.create(
            model="/root/xiedong/InternVL2-40B-AWQ",
            messages=[{
                'role': 'user',
                'content': [{
                    'type': 'text',
                    'text': 'Describe the image please',
                }, {
                    'type': 'image_url',
                    'image_url': {
                        'url': image_path,
                    },
                }],
            }],
            temperature=0.8,
            top_p=0.8
        )

        # 记录响应时间
        elapsed_time = time.time() - start_time
        total_time += elapsed_time

        # 打印当前请求的响应内容（可选）
        print(f"Response for {image_path}: {response.choices[0].message.content}")

    # 计算并记录该图像的平均响应时间
    average_speed = total_time / num_requests
    average_speeds[image_path] = average_speed

    print(f"Average speed for {image_path}: {average_speed} seconds")
    
# 输出所有图像的平均响应时间
for image_path, avg_speed in average_speeds.items():
    print(f"{image_path}: {avg_speed:.2f} seconds")
```

显存占用 72396MiB 。

#### 结果展示

- 384 x 256
- 768 x 512
- 1152 x 768
- 1536 x 1024
- 1920 x 1280
- 3840 x 2560

- demo256.jpeg: 3.39 seconds
- demo512.jpeg: 3.32 seconds
- demo768.jpeg: 3.43 seconds
- demo1024.jpeg: 3.65 seconds
- demo1280.jpeg: 3.40 seconds
- demo2560.jpeg: 3.99 seconds

测试结果表明，随着图片分辨率的提升，响应时间相应增加。


### InternVL2-Llama3-76B-AWQ 测试和评估


启动容器

使用以下命令启动Docker容器：

```bash
docker run --runtime nvidia --gpus all \
    -v /root/xiedong/:/root/xiedong/ \
    -p 23333:23333 \
    --ipc=host \
    -it --rm \
    kevinchina/deeplearning:internvl bash
```

启动API服务

```bash
lmdeploy serve api_server /root/xiedong/InternVL2-Llama3-76B-AWQ \
    --backend turbomind --server-port 23333 --model-format awq
```


#### 多次测试平均响应时间

对不同尺寸的图片进行10次请求并计算平均响应时间，代码如下：

```python
import time
from openai import OpenAI

# 初始化OpenAI客户端
client = OpenAI(api_key='YOUR_API_KEY', base_url='http://0.0.0.0:23333/v1')

# 定义图像路径
image_paths = [
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo256.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo512.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo768.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1024.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1280.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo2560.jpeg"
]

# 设置请求次数
num_requests = 10

# 存储每个图像的平均响应时间
average_speeds = {}

# 遍历每张图片
for image_path in image_paths:
    total_time = 0

    # 对每张图片执行 num_requests 次请求
    for _ in range(num_requests):
        start_time = time.time()

        # 发送请求并获取响应
        response = client.chat.completions.create(
            model="/root/xiedong/InternVL2-Llama3-76B-AWQ",
            messages=[{
                'role': 'user',
                'content': [{
                    'type': 'text',
                    'text': 'Describe the image please',
                }, {
                    'type': 'image_url',
                    'image_url': {
                        'url': image_path,
                    },
                }],
            }],
            temperature=0.8,
            top_p=0.8
        )

        # 记录响应时间
        elapsed_time = time.time() - start_time
        total_time += elapsed_time

        # 打印当前请求的响应内容（可选）
        print(f"Response for {image_path}: {response.choices[0].message.content}")

    # 计算并记录该图像的平均响应时间
    average_speed = total_time / num_requests
    average_speeds[image_path] = average_speed

    print(f"Average speed for {image_path}: {average_speed} seconds")
    
# 输出所有图像的平均响应时间
for image_path, avg_speed in average_speeds.items():
    print(f"{image_path}: {avg_speed:.2f} seconds")
```

显存占用76967MiB：

![image.png](/static/img/603ed96b460d34e3083aaeaf83d7718d.image.webp)

#### 结果展示

- 384 x 256
- 768 x 512
- 1152 x 768
- 1536 x 1024
- 1920 x 1280
- 3840 x 2560
- 
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo256.jpeg: 5.88 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo512.jpeg: 5.69 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo768.jpeg: 5.80 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1024.jpeg: 5.62 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1280.jpeg: 5.93 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo2560.jpeg: 5.80 seconds



### 测试结果

以下是根据你的描述整理的测试结果表格：


| Model                     | 显存占用 (MiB) | 分辨率      | 处理时间 (秒)  |
|---------------------------|---------------|-------------|----------------|
| **InternVL2-40B-AWQ**     | 72396         | 384 x 256   | 3.39           |
|                           |               | 768 x 512   | 3.32           |
|                           |               | 1152 x 768  | 3.43           |
|                           |               | 1536 x 1024 | 3.65           |
|                           |               | 1920 x 1280 | 3.40           |
|                           |               | 3840 x 2560 | 3.99           |
| **InternVL2-Llama3-76B-AWQ** | 76967      | 384 x 256   | 5.88           |
|                           |               | 768 x 512   | 5.69           |
|                           |               | 1152 x 768  | 5.80           |
|                           |               | 1536 x 1024 | 5.62           |
|                           |               | 1920 x 1280 | 5.93           |
|                           |               | 3840 x 2560 | 5.80           |

该表包含两个模型的显存占用情况及不同分辨率下的处理时间。


### InternVL2-26B-AWQ 测试和评估


启动容器

使用以下命令启动Docker容器：

```bash
docker run --runtime nvidia --gpus all \
    -v /root/xiedong/:/root/xiedong/ \
    -p 23333:23333 \
    --ipc=host \
    -it --rm \
    kevinchina/deeplearning:internvl bash
```

启动API服务

```bash
lmdeploy serve api_server /root/xiedong/InternVL2-26B-AWQ \
    --backend turbomind --server-port 23333 --model-format awq
```


#### 多次测试平均响应时间

对不同尺寸的图片进行10次请求并计算平均响应时间，代码如下：

```python
import time
from openai import OpenAI

# 初始化OpenAI客户端
client = OpenAI(api_key='YOUR_API_KEY', base_url='http://0.0.0.0:23333/v1')

# 定义图像路径
image_paths = [
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo256.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo512.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo768.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1024.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1280.jpeg",
    "/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo2560.jpeg"
]

# 设置请求次数
num_requests = 10

# 存储每个图像的平均响应时间
average_speeds = {}

# 遍历每张图片
for image_path in image_paths:
    total_time = 0

    # 对每张图片执行 num_requests 次请求
    for _ in range(num_requests):
        start_time = time.time()

        # 发送请求并获取响应
        response = client.chat.completions.create(
            model="/root/xiedong/InternVL2-26B-AWQ",
            messages=[{
                'role': 'user',
                'content': [{
                    'type': 'text',
                    'text': 'Describe the image please',
                }, {
                    'type': 'image_url',
                    'image_url': {
                        'url': image_path,
                    },
                }],
            }],
            temperature=0.8,
            top_p=0.8
        )

        # 记录响应时间
        elapsed_time = time.time() - start_time
        total_time += elapsed_time

        # 打印当前请求的响应内容（可选）
        print(f"Response for {image_path}: {response.choices[0].message.content}")

    # 计算并记录该图像的平均响应时间
    average_speed = total_time / num_requests
    average_speeds[image_path] = average_speed

    print(f"Average speed for {image_path}: {average_speed} seconds")
    
# 输出所有图像的平均响应时间
for image_path, avg_speed in average_speeds.items():
    print(f"{image_path}: {avg_speed:.2f} seconds")
```

显存占用 71997MiB ：


![image.png](/static/img/f5c1d8abdfe7fa91797420d8577a9b88.image.webp)


#### 结果展示

- 384 x 256
- 768 x 512
- 1152 x 768
- 1536 x 1024
- 1920 x 1280
- 3840 x 2560
- 
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo256.jpeg: 2.71 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo512.jpeg: 2.45 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo768.jpeg: 2.46 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1024.jpeg: 2.57 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo1280.jpeg: 2.59 seconds
- /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/demo2560.jpeg: 2.55 seconds