Qwen2.5 VL 72B Instruct GGUF

🚀 Qwen2.5-VL-72B-Instruct GGUF模型

Qwen2.5-VL-72B-Instruct GGUF模型是一种强大的多模态模型，可处理图像和文本输入，适用于多种场景，如视觉理解、视频分析等。它在Qwen2-VL的基础上进行了多项关键增强，提升了模型的性能和应用范围。

🚀 快速开始

使用llama.cpp运行Qwen 2.5 VL Instruct（截至2025年5月10日的最新版本）

1. 下载Qwen 2.5 VL gguf文件： 访问下载链接，选择名称中不包含mmproj的gguf文件。 例如：Qwen2.5-VL-72B-Instruct-q8_0.gguf，将此文件复制到您选择的文件夹。

2. 下载Qwen 2.5 VL mmproj文件： 访问下载链接，选择名称中包含mmproj的文件。 例如：Qwen2.5-VL-72B-Instruct-mmproj-f16.gguf，将此文件复制到您选择的文件夹。

3. 复制图像到gguf文件所在的同一文件夹或适当更改路径： 在以下示例中，gguf文件、图像和llama-mtmd-cli位于同一文件夹。 例如图像：car-1.jpg，将此文件复制到您选择的文件夹。

4. 运行CLI工具： 在您选择的文件夹中运行以下命令：

llama-mtmd-cli -m Qwen2.5-VL-72B-Instruct-q8_0.gguf --mmproj Qwen2.5-VL-72B-Instruct-mmproj-f16.gguf  -p "Describe this image." --image ./car-1.jpg

使用🤗 Transformers进行聊天

from transformers import Qwen2_5_VLForConditionalGeneration, AutoTokenizer, AutoProcessor
from qwen_vl_utils import process_vision_info

# 默认：将模型加载到可用设备上
model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2.5-VL-72B-Instruct", torch_dtype="auto", device_map="auto"
)

# 我们建议启用flash_attention_2以获得更好的加速和内存节省，特别是在多图像和视频场景中。
# model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
#     "Qwen/Qwen2.5-VL-72B-Instruct",
#     torch_dtype=torch.bfloat16,
#     attn_implementation="flash_attention_2",
#     device_map="auto",
# )

# 默认处理器
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-72B-Instruct")

# 模型中每张图像的视觉令牌数量的默认范围是4 - 16384。
# 您可以根据需要设置min_pixels和max_pixels，例如令牌范围为256 - 1280，以平衡性能和成本。
# min_pixels = 256*28*28
# max_pixels = 1280*28*28
# processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-72B-Instruct", min_pixels=min_pixels, max_pixels=max_pixels)

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg",
            },
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

# 推理准备
text = processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)
image_inputs, video_inputs = process_vision_info(messages)
inputs = processor(
    text=[text],
    images=image_inputs,
    videos=video_inputs,
    padding=True,
    return_tensors="pt",
)
inputs = inputs.to("cuda")

# 推理：生成输出
generated_ids = model.generate(**inputs, max_new_tokens=128)
generated_ids_trimmed = [
    out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
]
output_text = processor.batch_decode(
    generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

多图像推理

# 包含多个图像和文本查询的消息
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "file:///path/to/image1.jpg"},
            {"type": "image", "image": "file:///path/to/image2.jpg"},
            {"type": "text", "text": "Identify the similarities between these images."},
        ],
    }
]

# 推理准备
text = processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)
image_inputs, video_inputs = process_vision_info(messages)
inputs = processor(
    text=[text],
    images=image_inputs,
    videos=video_inputs,
    padding=True,
    return_tensors="pt",
)
inputs = inputs.to("cuda")

# 推理
generated_ids = model.generate(**inputs, max_new_tokens=128)
generated_ids_trimmed = [
    out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
]
output_text = processor.batch_decode(
    generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

视频推理

# 包含图像列表作为视频和文本查询的消息
messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video",
                "video": [
                    "file:///path/to/frame1.jpg",
                    "file:///path/to/frame2.jpg",
                    "file:///path/to/frame3.jpg",
                    "file:///path/to/frame4.jpg",
                ],
            },
            {"type": "text", "text": "Describe this video."},
        ],
    }
]

# 包含本地视频路径和文本查询的消息
messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video",
                "video": "file:///path/to/video1.mp4",
                "max_pixels": 360 * 420,
                "fps": 1.0,
            },
            {"type": "text", "text": "Describe this video."},
        ],
    }
]

# 包含视频URL和文本查询的消息
messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "video",
                "video": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2-VL/space_woaudio.mp4",
            },
            {"type": "text", "text": "Describe this video."},
        ],
    }
]

# 在Qwen 2.5 VL中，帧率信息也会输入到模型中以与绝对时间对齐。
# 推理准备
text = processor.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)
image_inputs, video_inputs, video_kwargs = process_vision_info(messages, return_video_kwargs=True)
inputs = processor(
    text=[text],
    images=image_inputs,
    videos=video_inputs,
    fps=fps,
    padding=True,
    return_tensors="pt",
    **video_kwargs,
)
inputs = inputs.to("cuda")

# 推理
generated_ids = model.generate(**inputs, max_new_tokens=128)
generated_ids_trimmed = [
    out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
]
output_text = processor.batch_decode(
    generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)

视频URL兼容性在很大程度上取决于第三方库版本。详细信息如下表所示。如果您不想使用默认的后端，可以通过FORCE_QWENVL_VIDEO_READER=torchvision或FORCE_QWENVL_VIDEO_READER=decord更改后端。

后端	HTTP	HTTPS
torchvision >= 0.19.0	✅	✅
torchvision < 0.19.0	❌	❌
decord	✅	❌

批量推理

# 批量推理的示例消息
messages1 = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "file:///path/to/image1.jpg"},
            {"type": "image", "image": "file:///path/to/image2.jpg"},
            {"type": "text", "text": "What are the common elements in these pictures?"},
        ],
    }
]
messages2 = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Who are you?"},
]
# 组合消息进行批量处理
messages = [messages1, messages2]

# 批量推理准备
texts = [
    processor.apply_chat_template(msg, tokenize=False, add_generation_prompt=True)
    for msg in messages
]
image_inputs, video_inputs = process_vision_info(messages)
inputs = processor(
    text=texts,
    images=image_inputs,
    videos=video_inputs,
    padding=True,
    return_tensors="pt",
)
inputs = inputs.to("cuda")

# 批量推理
generated_ids = model.generate(**inputs, max_new_tokens=128)
generated_ids_trimmed = [
    out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
]
output_texts = processor.batch_decode(
    generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_texts)

✨ 主要特性

关键增强

• 视觉理解能力：Qwen2.5-VL不仅擅长识别常见物体，如花鸟鱼虫，还能高度分析图像中的文本、图表、图标、图形和布局。
• 智能代理能力：Qwen2.5-VL可直接作为视觉代理，进行推理并动态调用工具，具备计算机和手机使用能力。
• 长视频理解和事件捕捉：Qwen2.5-VL能理解超过1小时的视频，并具备通过定位相关视频片段捕捉事件的新能力。
• 不同格式的视觉定位：Qwen2.5-VL可以通过生成边界框或点来准确地定位图像中的物体，并能为坐标和属性提供稳定的JSON输出。
• 结构化输出生成：对于发票、表单、表格等扫描数据，Qwen2.5-VL支持对其内容进行结构化输出，有利于金融、商业等领域的应用。

模型架构更新

• 用于视频理解的动态分辨率和帧率训练：通过采用动态FPS采样将动态分辨率扩展到时间维度，使模型能够理解不同采样率的视频。相应地，在时间维度上使用ID和绝对时间对齐更新mRoPE，使模型能够学习时间序列和速度，并最终获得定位特定时刻的能力。
• 精简高效的视觉编码器：通过将窗口注意力策略性地应用于ViT，提高了训练和推理速度。ViT架构进一步通过SwiGLU和RMSNorm进行优化，使其与Qwen2.5 LLM的结构保持一致。

📦 安装指南

Qwen2.5-VL的代码已包含在最新的Hugging face transformers中，建议使用以下命令从源代码进行构建：

pip install git+https://github.com/huggingface/transformers accelerate

否则，您可能会遇到以下错误：

KeyError: 'qwen2_5_vl'

同时，我们提供了一个工具包，可帮助您更方便地处理各种类型的视觉输入，就像使用API一样。可以使用以下命令进行安装：

# 强烈建议使用`[decord]`特性以实现更快的视频加载。
pip install qwen-vl-utils[decord]==0.0.8

如果您不使用Linux系统，可能无法从PyPI安装decord。在这种情况下，您可以使用pip install qwen-vl-utils，它将回退到使用torchvision进行视频处理。不过，您仍然可以从源代码安装decord，以便在加载视频时使用decord。

💻 使用示例

输入图像支持格式

# 您可以直接在文本中需要的位置插入本地文件路径、URL或Base64编码的图像。
## 本地文件路径
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "file:///path/to/your/image.jpg"},
            {"type": "text", "text": "Describe this image."},
        ],
    }
]
## 图像URL
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "http://path/to/your/image.jpg"},
            {"type": "text", "text": "Describe this image."},
        ],
    }
]
## Base64编码的图像
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "data:image;base64,/9j/..."},
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

图像分辨率设置

min_pixels = 256 * 28 * 28
max_pixels = 1280 * 28 * 28
processor = AutoProcessor.from_pretrained(
    "Qwen/Qwen2.5-VL-72B-Instruct", min_pixels=min_pixels, max_pixels=max_pixels
)

精细控制图像大小输入

# min_pixels和max_pixels
messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "file:///path/to/your/image.jpg",
                "resized_height": 280,
                "resized_width": 420,
            },
            {"type": "text", "text": "Describe this image."},
        ],
    }
]
# resized_height和resized_width
messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "file:///path/to/your/image.jpg",
                "min_pixels": 50176,
                "max_pixels": 50176,
            },
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

处理长文本

当前的config.json设置的上下文长度最大为32,768个令牌。为了处理超过32,768个令牌的大量输入，我们使用了YaRN技术来增强模型的长度外推能力，确保在长文本上的最佳性能。 对于支持的框架，您可以在config.json中添加以下内容以启用YaRN：

{
    ...,
    "type": "yarn",
    "mrope_section": [
        16,
        24,
        24
    ],
    "factor": 4,
    "original_max_position_embeddings": 32768
}

然而，需要注意的是，这种方法对时间和空间定位任务的性能有显著影响，因此不建议使用。同时，对于长视频输入，由于MRoPE本身在ids方面更节省，因此可以直接将max_position_embeddings修改为更大的值，例如64k。

📚 详细文档

模型评估

图像基准测试

基准测试	GPT4o	Claude3.5 Sonnet	Gemini-2-flash	InternVL2.5-78B	Qwen2-VL-72B	Qwen2.5-VL-72B
MMMUval	70.3	70.4	70.7	70.1	64.5	70.2
MMMU_Pro	54.5	54.7	57.0	48.6	46.2	51.1
MathVista_MINI	63.8	65.4	73.1	76.6	70.5	74.8
MathVision_FULL	30.4	38.3	41.3	32.2	25.9	38.1
Hallusion Bench	55.0	55.16		57.4	58.1	55.16
MMBench_DEV_EN_V11	82.1	83.4	83.0	88.5	86.6	88
AI2D_TEST	84.6	81.2		89.1	88.1	88.4
ChartQA_TEST	86.7	90.8	85.2	88.3	88.3	89.5
DocVQA_VAL	91.1	95.2	92.1	96.5	96.1	96.4
MMStar	64.7	65.1	69.4	69.5	68.3	70.8
MMVet_turbo	69.1	70.1		72.3	74.0	76.19
OCRBench	736	788		854	877	885
OCRBench-V2(en/zh)	46.5/32.3	45.2/39.6	51.9/43.1	45/46.2	47.8/46.1	61.5/63.7
CC-OCR	66.6	62.7	73.0	64.7	68.7	79.8

视频基准测试

基准测试	GPT4o	Gemini-1.5-Pro	InternVL2.5-78B	Qwen2VL-72B	Qwen2.5VL-72B
VideoMME w/o sub.	71.9	75.0	72.1	71.2	73.3
VideoMME w sub.	77.2	81.3	74.0	77.8	79.1
MVBench	64.6	60.5	76.4	73.6	70.4
MMBench-Video	1.63	1.30	1.97	1.70	2.02
LVBench	30.8	33.1		41.3	47.3
EgoSchema	72.2	71.2		77.9	76.2
PerceptionTest_test				68.0	73.2
MLVU_M-Avg_dev	64.6		75.7		74.6
TempCompass_overall	73.8				74.8

代理基准测试

基准测试	GPT4o	Gemini 2.0	Claude	Aguvis-72B	Qwen2VL-72B	Qwen2.5VL-72B
ScreenSpot	18.1	84.0	83.0			87.1
ScreenSpot Pro			17.1		1.6	43.6
AITZ_EM	35.3				72.8	83.2
Android Control High_EM				66.4	59.1	67.36
Android Control Low_EM				84.4	59.2	93.7
AndroidWorld_SR	34.5% (SoM)		27.9%	26.1%		35%
MobileMiniWob++_SR				66%		68%
OSWorld			14.90	10.26		8.83

选择合适的模型格式

选择正确的模型格式取决于您的硬件能力和内存限制。

BF16 (Brain Float 16) – 如果支持BF16加速则使用

• 一种16位浮点格式，旨在在保持良好精度的同时实现更快的计算。
• 提供与FP32相似的动态范围，但内存使用更低。
• 如果您的硬件支持BF16加速（请检查设备规格），建议使用。
• 与FP32相比，适用于具有减少内存占用的高性能推理。

使用BF16的情况：

• 您的硬件具有原生BF16支持（例如，较新的GPU、TPU）。
• 您希望在节省内存的同时获得更高的精度。
• 您计划将模型重新量化为另一种格式。

避免使用BF16的情况：

• 您的硬件不支持BF16（可能会回退到FP32并运行较慢）。
• 您需要与缺乏BF16优化的旧设备兼容。

F16 (Float 16) – 比BF16更广泛支持

• 一种16位浮点格式，具有高精度，但取值范围比BF16小。
• 适用于大多数支持FP16加速的设备（包括许多GPU和一些CPU）。
• 数值精度略低于BF16，但通常足以进行推理。

使用F16的情况：

• 您的硬件支持FP16但不支持BF16。
• 您需要在速度、内存使用和准确性之间取得平衡。
• 您在GPU或其他针对FP16计算进行优化的设备上运行。

避免使用F16的情况：

• 您的设备缺乏原生FP16支持（可能会比预期运行得慢）。
• 您有内存限制。

量化模型 (Q4_K, Q6_K, Q8等) – 用于CPU和低VRAM推理

量化可以在尽可能保持准确性的同时减小模型大小和内存使用。

• 低比特模型 (Q4_K) → 最适合最小化内存使用，可能精度较低。
• 高比特模型 (Q6_K, Q8_0) → 准确性更好，但需要更多内存。

使用量化模型的情况：

• 您在CPU上运行推理，需要优化的模型。
• 您的设备VRAM较低，无法加载全精度模型。
• 您希望在保持合理准确性的同时减少内存占用。

避免使用量化模型的情况：

• 您需要最高的准确性（全精度模型更适合这种情况）。
• 您的硬件有足够的VRAM用于更高精度的格式（BF16/F16）。

极低比特量化 (IQ3_XS, IQ3_S, IQ3_M, Q4_K, Q4_0)

这些模型针对极端内存效率进行了优化，非常适合低功耗设备或大规模部署，其中内存是关键限制因素。

• IQ3_XS：超低比特量化（3位），具有极端内存效率。
  • 使用场景：最适合超低内存设备，即使Q4_K也太大的情况。
  • 权衡：与高比特量化相比，准确性较低。
• IQ3_S：小块大小，以实现最大内存效率。
  • 使用场景：最适合低内存设备，当IQ3_XS过于激进时。
• IQ3_M：中等块大小，比IQ3_S具有更好的准确性。
  • 使用场景：适用于低内存设备，当IQ3_S过于受限的情况。
• Q4_K：4位量化，具有逐块优化以提高准确性。
  • 使用场景：最适合低内存设备，当Q6_K太大的情况。
• Q4_0：纯4位量化，针对ARM设备进行了优化。
  • 使用场景：最适合基于ARM的设备或低内存环境。

模型格式选择总结表

模型格式	精度	内存使用	设备要求	最佳使用场景
BF16	最高	高	支持BF16的GPU/CPU	具有减少内存的高速推理
F16	高	高	支持FP16的设备	当BF16不可用时的GPU推理
Q4_K	中低	低	CPU或低VRAM设备	最适合内存受限的环境
Q6_K	中	中等	内存更多的CPU	在量化的同时具有更好的准确性
Q8_0	高	中等	具有足够VRAM的CPU或GPU	量化模型中准确性最佳
IQ3_XS	非常低	非常低	超低内存设备	极端内存效率和低准确性
Q4_0	低	低	ARM或低内存设备	llama.cpp可以针对ARM设备进行优化

包含的文件及详细信息

Qwen2.5-VL-72B-Instruct-bf16.gguf

• 模型权重以BF16格式保存。
• 如果您想将模型重新量化为不同的格式，请使用此文件。
• 如果您的设备支持BF16加速，则最佳选择。

Qwen2.5-VL-72B-Instruct-f16.gguf

• 模型权重以F16格式保存。
• 如果您的设备支持FP16，尤其是在BF16不可用的情况下，请使用此文件。

Qwen2.5-VL-72B-Instruct-bf16-q8_0.gguf

• 输出和嵌入保持为BF16。
• 所有其他层量化为Q8_0。
• 如果您的设备支持BF16，并且您想要一个量化版本，请使用此文件。

Qwen2.5-VL-72B-Instruct-f16-q8_0.gguf

• 输出和嵌入保持为F16。
• 所有其他层量化为Q8_0。

Qwen2.5-VL-72B-Instruct-q4_k.gguf

• 输出和嵌入量化为Q8_0。
• 所有其他层量化为Q4_K。
• 适用于内存有限的CPU推理。

Qwen2.5-VL-72B-Instruct-q4_k_s.gguf

• 最小的Q4_K变体，以牺牲准确性为代价使用更少的内存。
• 最适合极低内存设置。

Qwen2.5-VL-72B-Instruct-q6_k.gguf

• 输出和嵌入量化为Q8_0。
• 所有其他层量化为Q6_K。

Qwen2.5-VL-72B-Instruct-q8_0.gguf

• 完全Q8量化的模型，以获得更好的准确性。
• 需要更多内存，但提供更高的精度。

Qwen2.5-VL-72B-Instruct-iq3_xs.gguf

• IQ3_XS量化，针对极端内存效率进行了优化。
• 最适合超低内存设备。

Qwen2.5-VL-72B-Instruct-iq3_m.gguf

• IQ3_M量化，提供中等块大小以获得更好的准确性。
• 适用于低内存设备。

Qwen2.5-VL-72B-Instruct-q4_0.gguf

• 纯Q4_0量化，针对ARM设备进行了优化。
• 最适合低内存环境。
• 为了获得更好的准确性，建议使用IQ4_NL。

🔧 技术细节

超低比特量化与IQ-DynamicGate (1 - 2位)

我们最新的量化方法为超低比特模型（1 - 2位）引入了精度自适应量化，并在Llama-3-8B上通过基准测试证明了其改进效果。这种方法使用特定层的策略来保持准确性，同时保持极高的内存效率。

基准测试背景

所有测试均在Llama-3-8B-Instruct上进行，使用以下条件：

• 标准困惑度评估管道
• 2048令牌上下文窗口
• 所有量化使用相同的提示集

方法

• 动态精度分配：
  • 前/后25%的层 → IQ4_XS（选定层）
  • 中间50% → IQ2_XXS/IQ3_S（提高效率）
• 关键组件保护：
  • 嵌入/输出层使用Q5_K
  • 与标准1 - 2位量化相比，将误差传播降低38%

量化性能比较 (Llama-3-8B)

量化方式	标准PPL	DynamicGate PPL	Δ PPL	标准大小	DG大小	Δ大小	标准速度	DG速度
IQ2_XXS	11.30	9.84	-12.9%	2.5G	2.6G	+0.1G	234s	246s
IQ2_XS	11.72	11.63	-0.8%	2.7G	2.8G	+0.1G	242s	246s
IQ2_S	14.31	9.02	-36.9%	2.7G	2.9G	+0.2G	238s	244s
IQ1_M	27.46	15.41	-43.9%	2.2G	2.5G	+0.3G	206s	212s
IQ1_S	53.07	32.00	-39.7%	2.1G	2.4G	+0.3G	184s	209s

关键说明：

• PPL = 困惑度（越低越好）
• Δ PPL = 从标准到DynamicGate的百分比变化
• 速度 = 推理时间（CPU avx2，2048令牌上下文）
• 大小差异反映了混合量化的开销

关键改进：

• 🔥 IQ1_M显示出巨大的43.9%的困惑度降低（从27.46降至15.41）
• 🚀 IQ2_S在仅增加0.2GB的情况下将困惑度降低了36.9%
• ⚡ IQ1_S尽管是1位量化，但仍保持了39.7%的更好准确性

权衡：

• 所有变体的大小都有适度增加（0.1 - 0.3GB）
• 推理速度仍然相当（差异<5%）

何时使用这些模型

• 📌 将模型装入GPU VRAM
• ✔ 内存受限的部署
• ✔ 可以容忍1 - 2位误差的CPU和边缘设备
• ✔ 超低比特量化的研究

📄 许可证

本项目采用Qwen许可证。

引用

如果您觉得我们的工作有帮助，请随意引用：

@misc{qwen2.5-VL,
    title = {Qwen2.5-VL},
    url = {https://qwenlm.github.io/blog/qwen2.5-vl/},
    author = {Qwen Team},
    month = {January},
    year = {2025}
}

@article{Qwen2VL,
  title={Qwen2-VL: Enhancing Vision-Language Model's Perception of the World at Any Resolution},
  author={Wang, Peng and Bai, Shuai and Tan, Sinan and Wang, Shijie and Fan, Zhihao and Bai, Jinze and Chen, Keqin and Liu, Xuejing and Wang, Jialin and Ge, Wenbin and Fan, Yang and Dang, Kai and Du, Mengfei and Ren, Xuancheng and Men, Rui and Liu, Dayiheng and Zhou, Chang and Zhou, Jingren and Lin, Junyang},
  journal={arXiv preprint arXiv:2409.12191},
  year={2024}
}

@article{Qwen-VL,
  title={Qwen-VL: A Versatile Vision-Language Model for Understanding, Localization, Text Reading, and Beyond},
  author={Bai, Jinze and Bai, Shuai and Yang, Shusheng and Wang, Shijie and Tan, Sinan and Wang, Peng and Lin, Junyang and Zhou, Chang and Zhou, Jingren},
  journal={arXiv preprint arXiv:2308.12966},
  year={2023}
}

其他说明

如果您觉得这些模型有用，请点击点赞 ❤。同时，如果您能测试我的网络监控助手，我将不胜感激。请点击👉 网络监控助手。

💬 点击聊天图标（主页和仪表盘页面的右下角），选择一个大语言模型；在LLM类型之间切换：TurboLLM -> FreeLLM -> TestLLM。

我正在测试的内容

我正在针对我的网络监控服务进行函数调用实验，使用小型开源模型。我关注的问题是“模型可以多小还能正常工作”。

🟡 TestLLM – 使用llama.cpp在CPU VM的6个线程上运行当前测试模型（加载大约需要15秒。推理速度相当慢，并且一次只能处理一个用户提示 – 仍在努力扩展！）。如果您感兴趣，我很乐意分享其工作原理！

其他可用的AI助手

🟢 TurboLLM – 使用gpt-4o-mini，速度快！注意：由于OpenAI模型价格昂贵，令牌有限，但您可以登录或下载免费的网络监控代理以获取更多令牌，或者使用TestLLM。

🔵 HugLLM – 运行开源Hugging Face模型，速度快，运行小型模型（≈8B），因此质量较低，可获得2倍的令牌（取决于Hugging Face API的可用性）。