Eagle2.5 8B

🚀 Eagle 2.5

Eagle 2.5是一系列前沿的视觉语言模型（VLM），专为长上下文多模态学习而设计。它解决了长视频理解和高分辨率图像理解的挑战，为这两个领域提供了通用框架。

项目链接

• 📂主页
• 📂GitHub
• 📜技术报告
• 🤗HF演示

🚀 快速开始

要使用Eagle 2.5，首先需要安装必要的库：

pip install transformers==4.51.0

✨ 主要特性

强大的长上下文处理能力

Eagle 2.5支持处理长达512帧的视频序列，在长视频理解和高分辨率图像理解方面表现出色，解决了现有大多数VLM专注于短上下文任务的局限。

优异的基准测试成绩

• 在10个长视频基准测试中的6个上达到了SOTA水平。
• 在3/5的视频任务中超越了GPT - 4o (0806)。
• 在4/6的视频任务中超越了Gemini 1.5 Pro。
• 在多个关键数据集上与Qwen2.5 - VL - 72B表现相当或更优。
• 在Video - MME上使用512输入帧时达到72.4%的准确率。
• 在图像理解方面相较于Eagle 2有持续提升，与Qwen2.5 - VL表现相当。

关键创新点

• 信息优先采样：
  • 图像区域保留（IAP）：优化图像分块，保留大部分原始图像区域和宽高比，保留细粒度细节。
  • 自动降级采样（ADS）：动态平衡视觉和文本输入，确保在上下文长度限制内完整保留文本的同时最大化视觉内容。
• 渐进式混合后训练：在训练过程中逐渐增加上下文长度，增强模型处理不同输入大小的能力，提高信息密度。
• 多样性驱动的数据配方：将开源数据（人工标注和合成数据）与精心策划的Eagle - Video - 110K数据集相结合，该数据集通过多样性驱动策略收集，并带有故事级和片段级的问答对标注。

效率与框架优化

• GPU内存优化：
  • 集成基于Triton的融合算子，替代PyTorch的MLP、RMSNorm和RoPE实现。
  • 通过融合线性层和交叉熵损失（去除中间logit存储）以及将隐藏状态卸载到CPU来减少GPU内存使用。
• 分布式上下文并行：
  • 采用基于Ulysses和Ring/Context Parallelism的两层通信组。
  • 实现ZigZag Llama3风格的上下文并行，使用全收集KV减少通信延迟。
• 视频解码加速：优化稀疏视频帧采样，快速解析视频元数据，提高长视频解码速度并减少内存消耗。
• 推理加速：支持vLLM部署，减少内存使用并加速推理。

📦 安装指南

安装所需的库：

pip install transformers==4.51.0

💻 使用示例

基础用法

单张图像

from PIL import Image
import requests
from transformers import AutoProcessor, AutoModel
import torch
model = AutoModel.from_pretrained("nvidia/Eagle-2.5-8B",trust_remote_code=True, torch_dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained("nvidia/Eagle-2.5-8B", trust_remote_code=True, use_fast=True)
processor.tokenizer.padding_side = "left"

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://www.ilankelman.org/stopsigns/australia.jpg",
            },
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

text_list = [processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)]
image_inputs, video_inputs = processor.process_vision_info(messages)
inputs = processor(text = text_list, images=image_inputs, videos=video_inputs, return_tensors="pt", padding=True)
inputs = inputs.to("cuda")
model = model.to("cuda")
generated_ids = model.generate(**inputs, max_new_tokens=1024)
output_text = processor.batch_decode(
    generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

高级用法

流式生成

from PIL import Image
import requests
from transformers import AutoProcessor, AutoModel, AutoTokenizer
import torch

from transformers import TextIteratorStreamer
import threading


model = AutoModel.from_pretrained("nvidia/Eagle-2.5-8B",trust_remote_code=True, attn_implementation='flash_attention_2', torch_dtype=torch.bfloat16)
tokenizer = AutoTokenizer.from_pretrained("nvidia/Eagle-2.5-8B", trust_remote_code=True, use_fast=True)
processor = AutoProcessor.from_pretrained("nvidia/Eagle-2.5-8B", trust_remote_code=True, use_fast=True)
processor.tokenizer.padding_side = "left"

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://www.ilankelman.org/stopsigns/australia.jpg",
            },
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

text_list = [processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)]
image_inputs, video_inputs = processor.process_vision_info(messages)
inputs = processor(text = text_list, images=image_inputs, videos=video_inputs, return_tensors="pt", padding=True)
inputs = inputs.to("cuda")
model = model.to("cuda")

streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)

generation_kwargs = dict(
    **inputs,
    streamer=streamer,
    max_new_tokens=1024,
    do_sample=True,
    top_p=0.95,
    temperature=0.8
)
thread = threading.Thread(target=model.generate, kwargs=generation_kwargs)
thread.start()


for new_text in streamer:
    print(new_text, end="", flush=True)

多张图像

from PIL import Image
import requests
from transformers import AutoProcessor, AutoModel
import torch
model = AutoModel.from_pretrained("nvidia/Eagle-2.5-8B",trust_remote_code=True, torch_dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained("nvidia/Eagle-2.5-8B", trust_remote_code=True, use_fast=True)
processor.tokenizer.padding_side = "left"

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://www.ilankelman.org/stopsigns/australia.jpg",
            },
            {
                "type": "image",
                "image": "https://www.nvidia.com/content/dam/en-zz/Solutions/about-nvidia/logo-and-brand/01-nvidia-logo-vert-500x200-2c50-d@2x.png",
            },
            {"type": "text", "text": "Describe these two images."},
        ],
    }
]

text_list = [processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)]
image_inputs, video_inputs = processor.process_vision_info(messages)
inputs = processor(text = text_list, images=image_inputs, videos=video_inputs, return_tensors="pt", padding=True)
inputs = inputs.to("cuda")
model = model.to("cuda")
generated_ids = model.generate(**inputs, max_new_tokens=1024)
output_text = processor.batch_decode(
    generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

单视频

from PIL import Image
import requests
from transformers import AutoProcessor, AutoModel
import torch
model = AutoModel.from_pretrained("nvidia/Eagle-2.5-8B",trust_remote_code=True, torch_dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained("nvidia/Eagle-2.5-8B", trust_remote_code=True, use_fast=True)
processor.tokenizer.padding_side = "left"

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video",
                "video": "../Eagle2-8B/space_woaudio.mp4",
            },
            {"type": "text", "text": "Describe this video."},
        ],
    }
]

text_list = [processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)]
image_inputs, video_inputs, video_kwargs = processor.process_vision_info(messages, return_video_kwargs=True)

inputs = processor(text = text_list, images=image_inputs, videos=video_inputs, return_tensors="pt", padding=True, videos_kwargs=video_kwargs)
inputs = inputs.to("cuda")
model = model.to("cuda")
generated_ids = model.generate(**inputs, max_new_tokens=1024)
output_text = processor.batch_decode(
    generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

多视频

from PIL import Image
import requests
from transformers import AutoProcessor, AutoModel
import torch
model = AutoModel.from_pretrained("nvidia/Eagle-2.5-8B",trust_remote_code=True, torch_dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained("nvidia/Eagle-2.5-8B", trust_remote_code=True, use_fast=True)
processor.tokenizer.padding_side = "left"

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video",
                "video": "../Eagle2-8B/space_woaudio.mp4",
                "nframes": 10,
            },
            {
                "type": "video",
                "video": "../Eagle2-8B/video_ocr.mp4",
                "nframes": 10,
            },
            {"type": "text", "text": "Describe these two videos respectively."},
        ],
    }
]

text_list = [processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)]
image_inputs, video_inputs, video_kwargs = processor.process_vision_info(messages, return_video_kwargs=True)
inputs = processor(text = text_list, images=image_inputs, videos=video_inputs, return_tensors="pt", padding=True, videos_kwargs=video_kwargs)
inputs = inputs.to("cuda")
model = model.to("cuda")
generated_ids = model.generate(**inputs, max_new_tokens=1024)
output_text = processor.batch_decode(
    generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

批量推理

from PIL import Image
import requests
from transformers import AutoProcessor, AutoModel
import torch
model = AutoModel.from_pretrained("nvidia/Eagle-2.5-8B",trust_remote_code=True, torch_dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained("nvidia/Eagle-2.5-8B", trust_remote_code=True, use_fast=True)
processor.tokenizer.padding_side = "left"

messages1 = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://www.ilankelman.org/stopsigns/australia.jpg",
            },
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

messages2 = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://www.nvidia.com/content/dam/en-zz/Solutions/about-nvidia/logo-and-brand/01-nvidia-logo-vert-500x200-2c50-d@2x.png",
            },
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

text_list = [processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
) for messages in [messages1, messages2]]
image_inputs, video_inputs = processor.process_vision_info([messages1, messages2])
inputs = processor(text = text_list, images=image_inputs, videos=video_inputs, return_tensors="pt", padding=True)
inputs = inputs.to("cuda")
model = model.to("cuda")
generated_ids = model.generate(**inputs, max_new_tokens=1024)
output_text = processor.batch_decode(
    generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

📚 详细文档

模型详情

发布的模型

视频基准测试

具身基准测试

图像基准测试

🔧 技术细节

信息优先采样

• 图像区域保留（IAP）：通过优化图像分块方式，尽可能保留原始图像的区域和宽高比，从而保留图像中的细粒度细节，有助于模型更准确地理解图像内容。
• 自动降级采样（ADS）：在处理视觉和文本输入时，根据上下文长度的限制，动态平衡两者的比例，确保在不丢失文本信息的前提下，最大化利用视觉内容。

渐进式混合后训练

在训练过程中，逐渐增加上下文长度，从32K扩展到128K。这种方式使模型能够适应不同大小的输入，提高了模型处理长上下文信息的能力，同时增加了信息密度。

多样性驱动的数据配方

结合开源的视频和文档数据集以及自主策划的Eagle - Video - 110K数据集。该数据集通过多样性驱动的策略收集，包含超过110K个带有故事级和片段级标注的长视频样本，为模型训练提供了丰富多样的数据。

效率优化

• GPU内存优化：
  • 采用基于Triton的融合算子，替代PyTorch的MLP、RMSNorm和RoPE实现，提高计算效率。
  • 通过融合线性层和交叉熵损失，去除中间logit存储，减少了GPU内存的使用。同时，将隐藏状态卸载到CPU，进一步优化内存占用。
• 分布式上下文并行：
  • 采用基于Ulysses和Ring/Context Parallelism的两层通信组，结合ZigZag Llama3风格的上下文并行，使用全收集KV减少通信延迟，提高分布式训练的效率。
• 视频解码加速：优化稀疏视频帧采样算法，快速解析视频元数据，提高长视频解码速度，同时减少内存消耗。
• 推理加速：支持vLLM部署，减少推理过程中的内存使用，加速模型推理。

📄 许可证

本项目采用nsclv1许可证。