模型简介
模型特点
模型能力
使用案例
🚀 InternVL3-8B
InternVL3-8B是一款先进的多模态大语言模型,具备卓越的多模态感知和推理能力,在工具使用、GUI代理、工业图像分析等多领域表现出色。
- GitHub
- InternVL 1.0
- InternVL 1.5
- InternVL 2.5
- InternVL2.5-MPO
- InternVL3
- Blog
- Chat Demo
- HF Demo
- Quick Start
- Documents

✨ 主要特性
- 相比InternVL 2.5,InternVL3展现出更卓越的多模态感知和推理能力,其多模态能力进一步拓展至工具使用、GUI代理、工业图像分析、3D视觉感知等领域。
- 得益于原生多模态预训练,InternVL3系列在整体文本性能上甚至优于Qwen2.5系列。
- 集成了可变视觉位置编码(V2PE),使InternVL3在长上下文理解能力上优于前代模型。
📚 详细文档
InternVL3家族
以下表格概述了InternVL3系列:
模型名称 | 视觉部分 | 语言部分 | HF链接 |
---|---|---|---|
InternVL3-1B | InternViT-300M-448px-V2_5 | Qwen2.5-0.5B | 链接 |
InternVL3-2B | InternViT-300M-448px-V2_5 | Qwen2.5-1.5B | 链接 |
InternVL3-8B | InternViT-300M-448px-V2_5 | Qwen2.5-7B | 链接 |
InternVL3-9B | InternViT-300M-448px-V2_5 | internlm3-8b-instruct | 链接 |
InternVL3-14B | InternViT-300M-448px-V2_5 | Qwen2.5-14B | 链接 |
InternVL3-38B | InternViT-6B-448px-V2_5 | Qwen2.5-32B | 链接 |
InternVL3-78B | InternViT-6B-448px-V2_5 | Qwen2.5-72B | 链接 |
模型架构
如下图所示,InternVL3沿用了与InternVL 2.5及其前代模型InternVL 1.5和2.0相同的模型架构,遵循“ViT - MLP - LLM”范式。在这个新版本中,我们使用随机初始化的MLP投影器,将新的增量预训练的InternViT与各种预训练的大语言模型(LLM)集成,包括InternLM 3和Qwen 2.5。
与之前的版本一样,我们应用了像素重排操作,将视觉标记的数量减少到原来的四分之一。此外,我们采用了与InternVL 1.5类似的动态分辨率策略,将图像分割成448×448像素的图块。从InternVL 2.0开始的主要区别在于,我们还引入了对多图像和视频数据的支持。
值得注意的是,在InternVL3中,我们集成了可变视觉位置编码(V2PE),它为视觉标记使用更小、更灵活的位置增量。得益于V2PE,InternVL3在长上下文理解能力上优于前代模型。
训练策略
原生多模态预训练
我们提出了一种原生多模态预训练方法,将语言和视觉学习整合到一个预训练阶段。与先训练仅语言模型,然后将其适配以处理其他模态的标准范式不同,我们的方法将多模态数据(如图文、视频文本或图文交错序列)与大规模文本语料交织在一起。这种统一的训练方案使模型能够同时学习语言和多模态表示,最终提高其处理视觉语言任务的能力,而无需单独的对齐或桥接模块。更多细节请参阅我们的论文。
监督微调
在这个阶段,InternVL2.5中提出的随机JPEG压缩、平方损失重新加权和多模态数据打包技术也被应用于InternVL3系列。与InternVL2.5相比,InternVL3的监督微调阶段的主要进步在于使用了更高质量和更多样化的训练数据。具体来说,我们进一步扩展了工具使用、3D场景理解、GUI操作、长上下文任务、视频理解、科学图表、创意写作和多模态推理的训练样本。
混合偏好优化
在预训练和监督微调期间,模型被训练为根据先前的真实标记预测下一个标记。然而,在推理期间,模型根据自己的先前输出预测每个标记。这种真实标记和模型预测标记之间的差异引入了分布偏移,这可能会损害模型的思维链(CoT)推理能力。为了缓解这个问题,我们采用了MPO,它引入了来自正样本和负样本的额外监督,以使模型响应分布与真实分布对齐,从而提高推理性能。具体来说,MPO的训练目标是偏好损失 \(\mathcal{L}{\text{p}}\)、质量损失 \(\mathcal{L}{\text{q}}\) 和生成损失 \(\mathcal{L}{\text{g}}\) 的组合,可以表述如下: $$ \mathcal{L}=w{p}\cdot\mathcal{L}{\text{p}} + w{q}\cdot\mathcal{L}{\text{q}} + w{g}\cdot\mathcal{L}{\text{g}}, $$ 其中 \(w{*}\) 表示每个损失组件的权重。有关MPO的更多细节,请参阅我们的论文。
测试时缩放
测试时缩放已被证明是一种有效的方法,可以增强大语言模型和多模态大语言模型的推理能力。在这项工作中,我们使用N选最佳评估策略,并使用VisualPRM-8B作为评判模型,为推理和数学评估选择最佳响应。
多模态能力评估
多模态推理和数学
OCR、图表和文档理解
多图像和现实世界理解
综合多模态和幻觉评估
视觉定位
多模态多语言理解
视频理解
GUI定位
空间推理
语言能力评估
我们将InternVL3与Qwen2.5聊天模型进行了比较,后者对应的预训练基础模型被用作InternVL3中语言组件的初始化。得益于原生多模态预训练,InternVL3系列在整体文本性能上甚至优于Qwen2.5系列。请注意,Qwen2.5系列的评估分数可能与官方报告的分数不同,因为我们在所有数据集上采用了表中提供的提示版本进行OpenCompass评估。
消融研究
原生多模态预训练
我们在InternVL2-8B模型上进行了实验,同时保持其架构、初始化参数和训练数据完全不变。传统上,InternVL2-8B采用的训练管道是先进行MLP预热阶段以进行特征对齐,然后进行指令微调阶段。在我们的实验中,我们用原生多模态预训练过程取代了传统的MLP预热阶段。这种修改隔离了原生多模态预训练对模型整体多模态能力的贡献。
下图中的评估结果表明,采用原生多模态预训练的模型在大多数基准测试中的性能与经过完整多阶段训练的InternVL2-8B基线相当。此外,当在更高质量的数据上进行指令微调后,该模型在评估的多模态任务中表现出进一步的性能提升。这些发现强调了原生多模态预训练在赋予多模态大语言模型强大多模态能力方面的效率。
混合偏好优化
如下表所示,与未使用MPO的模型相比,使用MPO进行微调的模型在七个多模态推理基准测试中表现出更优越的推理性能。具体来说,InternVL3-78B和InternVL3-38B分别比其对应模型高出4.1和4.5分。值得注意的是,用于MPO的训练数据是用于监督微调的训练数据的子集,这表明性能提升主要源于训练算法,而非训练数据。
可变视觉位置编码
如下表所示,引入V2PE在大多数评估指标上带来了显著的性能提升。此外,我们通过改变位置增量 \( \delta \) 进行的消融研究表明,即使对于主要涉及常规上下文的任务,相对较小的 \( \delta \) 值也能实现最佳性能。这些发现为未来改进多模态大语言模型中视觉标记的位置编码策略提供了重要见解。
🔧 技术细节
原生多模态预训练
将语言和视觉学习整合到一个预训练阶段,通过将多模态数据与大规模文本语料交织,使模型能同时学习语言和多模态表示,提升处理视觉语言任务的能力。
监督微调
采用随机JPEG压缩、平方损失重新加权和多模态数据打包技术,使用更高质量和更多样化的训练数据,扩展了多种任务的训练样本。
混合偏好优化
引入额外监督,使模型响应分布与真实分布对齐,缓解推理时的分布偏移问题,提高推理性能。
可变视觉位置编码(V2PE)
为视觉标记使用更小、更灵活的位置增量,提升模型的长上下文理解能力。
💻 使用示例
基础用法
我们提供了一个使用transformers
运行InternVL3-8B
的示例代码。
⚠️ 重要提示
请使用transformers>=4.37.2以确保模型正常工作。
16位(bf16 / fp16)
import torch
from transformers import AutoTokenizer, AutoModel
path = "OpenGVLab/InternVL3-8B"
model = AutoModel.from_pretrained(
path,
torch_dtype=torch.bfloat16,
low_cpu_mem_usage=True,
use_flash_attn=True,
trust_remote_code=True).eval().cuda()
BNB 8位量化
import torch
from transformers import AutoTokenizer, AutoModel
path = "OpenGVLab/InternVL3-8B"
model = AutoModel.from_pretrained(
path,
torch_dtype=torch.bfloat16,
load_in_8bit=True,
low_cpu_mem_usage=True,
use_flash_attn=True,
trust_remote_code=True).eval()
多GPU
以下代码这样编写的原因是为了避免在多GPU推理过程中,由于张量不在同一设备上而出现的错误。通过确保大语言模型(LLM)的第一层和最后一层在同一设备上,我们可以防止此类错误。
import math
import torch
from transformers import AutoTokenizer, AutoModel
def split_model(model_name):
device_map = {}
world_size = torch.cuda.device_count()
config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)
num_layers = config.llm_config.num_hidden_layers
# Since the first GPU will be used for ViT, treat it as half a GPU.
num_layers_per_gpu = math.ceil(num_layers / (world_size - 0.5))
num_layers_per_gpu = [num_layers_per_gpu] * world_size
num_layers_per_gpu[0] = math.ceil(num_layers_per_gpu[0] * 0.5)
layer_cnt = 0
for i, num_layer in enumerate(num_layers_per_gpu):
for j in range(num_layer):
device_map[f'language_model.model.layers.{layer_cnt}'] = i
layer_cnt += 1
device_map['vision_model'] = 0
device_map['mlp1'] = 0
device_map['language_model.model.tok_embeddings'] = 0
device_map['language_model.model.embed_tokens'] = 0
device_map['language_model.output'] = 0
device_map['language_model.model.norm'] = 0
device_map['language_model.model.rotary_emb'] = 0
device_map['language_model.lm_head'] = 0
device_map[f'language_model.model.layers.{num_layers - 1}'] = 0
return device_map
path = "OpenGVLab/InternVL3-8B"
device_map = split_model('InternVL3-8B')
model = AutoModel.from_pretrained(
path,
torch_dtype=torch.bfloat16,
low_cpu_mem_usage=True,
use_flash_attn=True,
trust_remote_code=True,
device_map=device_map).eval()
高级用法
import math
import numpy as np
import torch
import torchvision.transforms as T
from decord import VideoReader, cpu
from PIL import Image
from torchvision.transforms.functional import InterpolationMode
from transformers import AutoModel, AutoTokenizer
IMAGENET_MEAN = (0.485, 0.456, 0.406)
IMAGENET_STD = (0.229, 0.224, 0.225)
def build_transform(input_size):
MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
transform = T.Compose([
T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
T.ToTensor(),
T.Normalize(mean=MEAN, std=STD)
])
return transform
def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
best_ratio_diff = float('inf')
best_ratio = (1, 1)
area = width * height
for ratio in target_ratios:
target_aspect_ratio = ratio[0] / ratio[1]
ratio_diff = abs(aspect_ratio - target_aspect_ratio)
if ratio_diff < best_ratio_diff:
best_ratio_diff = ratio_diff
best_ratio = ratio
elif ratio_diff == best_ratio_diff:
if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
best_ratio = ratio
return best_ratio
def dynamic_preprocess(image, min_num=1, max_num=12, image_size=448, use_thumbnail=False):
orig_width, orig_height = image.size
aspect_ratio = orig_width / orig_height
# calculate the existing image aspect ratio
target_ratios = set(
(i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
i * j <= max_num and i * j >= min_num)
target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
# find the closest aspect ratio to the target
target_aspect_ratio = find_closest_aspect_ratio(
aspect_ratio, target_ratios, orig_width, orig_height, image_size)
# calculate the target width and height
target_width = image_size * target_aspect_ratio[0]
target_height = image_size * target_aspect_ratio[1]
blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
# resize the image
resized_img = image.resize((target_width, target_height))
processed_images = []
for i in range(blocks):
box = (
(i % (target_width // image_size)) * image_size,
(i // (target_width // image_size)) * image_size,
((i % (target_width // image_size)) + 1) * image_size,
((i // (target_width // image_size)) + 1) * image_size
)
# split the image
split_img = resized_img.crop(box)
processed_images.append(split_img)
assert len(processed_images) == blocks
if use_thumbnail and len(processed_images) != 1:
thumbnail_img = image.resize((image_size, image_size))
processed_images.append(thumbnail_img)
return processed_images
def load_image(image_file, input_size=448, max_num=12):
image = Image.open(image_file).convert('RGB')
transform = build_transform(input_size=input_size)
images = dynamic_preprocess(image, image_size=input_size, use_thumbnail=True, max_num=max_num)
pixel_values = [transform(image) for image in images]
pixel_values = torch.stack(pixel_values)
return pixel_values
def split_model(model_name):
device_map = {}
world_size = torch.cuda.device_count()
config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)
num_layers = config.llm_config.num_hidden_layers
# Since the first GPU will be used for ViT, treat it as half a GPU.
num_layers_per_gpu = math.ceil(num_layers / (world_size - 0.5))
num_layers_per_gpu = [num_layers_per_gpu] * world_size
num_layers_per_gpu[0] = math.ceil(num_layers_per_gpu[0] * 0.5)
layer_cnt = 0
for i, num_layer in enumerate(num_layers_per_gpu):
for j in range(num_layer):
📄 许可证
本项目采用Qwen许可证。









