2025 Complete Guide: In-Depth Analysis of ERNIE-4.5-VL-28B-A3B-Thinking Multimodal AI Model

🎯 Key Takeaways (TL;DR)

• 
  Lightweight & Efficient: Activates only 3B parameters while matching top-tier flagship model performance


• 
  Breakthrough Reasoning: Achieves exceptional visual reasoning and STEM problem-solving through large-scale reinforcement learning


• 
  Innovative Features: Supports "Thinking with Images", visual grounding, tool calling, and video understanding


• 
  Easy Deployment: Supports multiple inference frameworks including Transformers, vLLM, and FastDeploy


• 
  Open Source Friendly: Licensed under Apache 2.0, allowing commercial use

Table of Contents

1. What is ERNIE-4.5-VL-28B-A3B-Thinking


2. Core Technical Highlights


3. Six Key Capabilities Explained


4. Performance Benchmarks


5. Quick Start Guide


6. Deployment Options Comparison


7. Fine-tuning and Training


8. Frequently Asked Questions


9. Summary and Recommendations

What is ERNIE-4.5-VL-28B-A3B-Thinking

ERNIE-4.5-VL-28B-A3B-Thinking is Baidu's latest generation multimodal AI model, built upon the powerful ERNIE-4.5-VL-28B-A3B architecture. It's a large language model specifically optimized for vision-language understanding tasks, having absorbed massive amounts of high-quality visual-language reasoning data through extensive mid-training phases.

💡 Expert Tip

The model's key feature is its MoE (Mixture of Experts) architecture. While the total parameter count is 28B, only 3B parameters are activated during inference, enabling it to maintain high performance while dramatically reducing computational costs.

Core Innovations

• 
  Large-scale Vision-Language Training: Absorbed vast amounts of premium visual-language reasoning data during mid-training


• 
  Deep Semantic Alignment: Significantly enhanced semantic alignment between visual and language modalities


• 
  Advanced Reinforcement Learning: Employs GSPO and IcePop strategies combined with dynamic difficulty sampling for efficient learning


• 
  Enhanced Instruction Following: Dramatically improved visual grounding performance and instruction execution capabilities

Core Technical Highlights

Training Technology Innovations

Architectural Advantages

MoE (Mixture of Experts) Architecture enables the model to:

• Activate only necessary 3B parameters during inference


• Maintain 28B parameter knowledge capacity


• Significantly reduce inference costs and latency


• Achieve better energy efficiency

⚠️ Important Note

Although the model activates only 3B parameters, single-card deployment requires at least 80GB GPU memory. This is because the complete model weights need to be loaded, even though only a portion is activated during inference.

Six Key Capabilities Explained

1. 🧠 Visual Reasoning

Core Strengths:

• Multi-step complex reasoning


• Chart analysis and interpretation


• Causal relationship reasoning

Application Scenarios:

• Complex chart data analysis


• Visual logic problem solving


• Scene understanding and inference

Empowered by large-scale reinforcement learning, the model demonstrates exceptional multi-step reasoning capabilities in complex visual tasks. Whether analyzing intricate statistical charts or understanding causal relationships in images, ERNIE-4.5-VL-Thinking delivers accurate analytical results.

2. 🔬 STEM Reasoning

Breakthrough Performance:

• Solving math problems from photos


• Physics formula recognition and calculation


• Geometric figure analysis

Practical Value:

• Educational assistance tools


• Homework grading systems


• Scientific research data analysis

Leveraging powerful visual capabilities, the model achieves a performance leap in STEM tasks. It can directly recognize mathematical formulas and geometric figures from photos and perform accurate calculations and reasoning, handling even complex problems with ease.

3. 📍 Visual Grounding

Enhanced Features:

• More precise object localization


• Flexible instruction execution


• Complex industrial scenario adaptation

Typical Applications:

• Industrial quality inspection


• Autonomous driving scene understanding


• Robot visual navigation

Responding to strong community demand, the model significantly enhances visual grounding performance. Improved instruction-following capabilities make grounding functions more accessible, easily triggering localization in complex industrial scenarios for dramatic efficiency gains.

4. 🤔 Thinking with Images

Innovative Functionality:

• Thinks like humans


• Freely zooms image details


• Progressive information extraction

Workflow:

User Input Image → Initial Analysis → Identify Key Regions → 

Zoom Detail Inspection → Synthesize Information → Generate Complete Answer

This is one of the model's most innovative features. When paired with tools like image zooming and image search, "Thinking with Images" dramatically elevates the model's ability to process fine-grained details and handle long-tail visual knowledge. The model thinks like a human, first observing the whole, then zooming into key regions for careful inspection, and finally synthesizing all information to provide an answer.

✅ Best Practice

When processing high-resolution images or pictures with abundant details, enabling "Thinking with Images" can significantly improve recognition accuracy.

5. 🛠️ Tool Utilization

Supported Tool Types:

• Image search


• Image zooming


• External knowledge base queries


• Calculator and other auxiliary tools

Advantages:

• Handle long-tail knowledge


• Real-time information retrieval


• Enhanced problem-solving capabilities

Empowered by robust tool-calling capabilities, the model can instantly use functions like image search to easily identify long-tail knowledge and achieve comprehensive information retrieval. These enhancements form a critical foundation for developing sophisticated multimodal agents.

6. 🎬 Video Understanding

Core Capabilities:

• Outstanding temporal awareness


• Precise event localization


• Cross-frame content change recognition

Application Domains:

• Video content moderation


• Intelligent video editing


• Surveillance video analysis


• Sports event analysis

The model possesses outstanding temporal awareness and event localization abilities, accurately identifying content changes across different time segments in videos, making video analysis smarter and more efficient.

Performance Benchmarks

According to official benchmark results, ERNIE-4.5-VL-28B-A3B-Thinking performs excellently across multiple evaluation benchmarks. As a lightweight model activating only 3B parameters, its performance closely matches or even exceeds industry-leading flagship models.

Comparison with Top Models

📊 Performance Highlights

Official benchmark charts show the model approaches or exceeds industry-leading flagship models across multiple dimensions while maintaining significant parameter efficiency advantages. This means users can achieve top-tier performance at lower costs.

Key Performance Metrics

• 
  Inference Speed: Thanks to only 3B activated parameters, inference is 2-3x faster than equivalent full-parameter models


• 
  Memory Footprint: While 80GB is needed to load the model, inference memory usage is far lower than traditional large models


• 
  Accuracy: Achieves SOTA levels across multiple vision-language understanding benchmarks


• 
  Generalization: Maintains strong performance on unseen tasks

Quick Start Guide

Method 1: Using Transformers Library (Recommended for Beginners)

Suitable For:

• Rapid prototyping


• Small-scale inference tasks


• Learning and experimentation


• Single or low-frequency calls

Basic Code Example:

import torch

from transformers import AutoProcessor, AutoTokenizer, AutoModelForCausalLM



# Load model

model_path = 'baidu/ERNIE-4.5-VL-28B-A3B-Thinking'

model = AutoModelForCausalLM.from_pretrained(

    model_path,

    device_map="auto",

    dtype=torch.bfloat16,

    trust_remote_code=True

)



# Load processor

processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)

model.add_image_preprocess(processor)



# Build messages

messages = [

    {

        "role": "user",

        "content": [

            {"type": "text", "text": "What color clothes is the girl wearing in the picture?"},

            {

                "type": "image_url",

                "image_url": {

                    "url": "https://paddlenlp.bj.bcebos.com/datasets/paddlemix/demo_images/example1.jpg"

                }

            },

        ]

    },

]



# Process input

text = processor.tokenizer.apply_chat_template(

    messages,

    tokenize=False,

    add_generation_prompt=True,

)

image_inputs, video_inputs = processor.process_vision_info(messages)

inputs = processor(

    text=[text],

    images=image_inputs,

    videos=video_inputs,

    padding=True,

    return_tensors="pt",

)



# Generate response

device = next(model.parameters()).device

inputs = inputs.to(device)

generated_ids = model.generate(

    inputs=inputs['input_ids'].to(device),

    **inputs,

    max_new_tokens=1024,

    use_cache=False

)

output_text = processor.decode(generated_ids[0][len(inputs['input_ids'][0]):])

print(output_text)

Key Parameter Explanations:

• 
  device_map="auto": Automatically allocates model to available devices


• 
  dtype=torch.bfloat16: Uses bfloat16 precision, balancing performance and accuracy


• 
  trust_remote_code=True: Allows execution of custom code from model repository


• 
  max_new_tokens=1024: Controls maximum length of generated text

Method 2: Using vLLM (Recommended for Production)

Suitable For:

• High-concurrency inference services


• Production environment deployment


• Applications requiring high throughput


• API service construction

Installation Steps:

# Install uv package manager

pip install uv



# Install vLLM main branch

uv pip install -U vllm --pre \

  --extra-index-url https://wheels.vllm.ai/nightly \

  --extra-index-url https://download.pytorch.org/whl/cu129 \

  --index-strategy unsafe-best-match

Start Service:

# Basic startup (requires 80G memory)

vllm serve baidu/ERNIE-4.5-VL-28B-A3B-Thinking --trust-remote-code



# If encountering memory shortage, add the following parameter

vllm serve baidu/ERNIE-4.5-VL-28B-A3B-Thinking \

  --trust-remote-code \

  --gpu-memory-utilization 0.95

Enable Reasoning Parser and Tool Calling:

vllm serve baidu/ERNIE-4.5-VL-28B-A3B-Thinking \

  --trust-remote-code \

  --reasoning-parser ernie45 \

  --tool-call-parser ernie45 \

  --enable-auto-tool-choice

vLLM Advantages:

• 
  PagedAttention: Efficient memory management, supports larger batches


• 
  Continuous Batching: Dynamically batches requests, maximizes GPU utilization


• 
  Optimized CUDA Kernels: Specially optimized inference kernels for faster speed


• 
  OpenAI-Compatible API: Provides OpenAI API-compatible interface

Method 3: Using FastDeploy (Recommended for Enterprise)

Suitable For:

• Enterprise-grade production deployment


• Requiring quantization acceleration


• Multi-instance load balancing


• Complete monitoring and management

Quick Start:

fastdeploy serve --model baidu/ERNIE-4.5-VL-28B-A3B-Thinking \

  --max-model-len 131072 \

  --max-num-seqs 32 \

  --port 8180 \

  --quantization wint8 \

  --reasoning-parser ernie-45-vl-thinking \

  --tool-call-parser ernie-45-vl-thinking \

  --mm-processor-kwargs '{"image_max_pixels": 12845056 }'

Parameter Details:

• 
  --max-model-len 131072: Maximum supported sequence length


• 
  --max-num-seqs 32: Maximum concurrent sequences


• 
  --quantization wint8: Uses 8-bit integer quantization, reduces memory usage


• 
  --mm-processor-kwargs: Multimodal processor parameters, controls maximum image pixels

💡 Expert Tip

FastDeploy supports wint8 quantization, reducing memory requirements from 80GB to approximately 60GB while maintaining performance. This is the best choice for memory-constrained scenarios.

Deployment Options Comparison

Detailed Comparison Table

Performance Comparison

Selection Recommendations

If you are:

• 
  

  AI Researcher/Student → Choose Transformers

  
  
  
  
  
  • ✅ Easy to experiment and debug
  
  
  • ✅ Full model access
  
  
  • ✅ Rich documentation and community support
  
  
  • ❌ Not optimal performance
  
  
  
  
  
  



• 
  
  

  Startup/Individual Developer → Choose vLLM

  
  
  
  
  
  • ✅ Balanced performance and ease of use
  
  
  • ✅ OpenAI-compatible API
  
  
  • ✅ Active community
  
  
  • ✅ Free and open source
  
  
  
  
  
  



• 
  
  

  Large Enterprise → Choose FastDeploy

  
  
  
  
  
  • ✅ Complete enterprise-grade support
  
  
  • ✅ Quantization optimization
  
  
  • ✅ Monitoring and management features
  
  
  • ✅ Long-term maintenance guarantee
  
  
  
  
  
  

Fine-tuning and Training

Fine-tuning with ERNIEKit

ERNIEKit is a training toolkit based on PaddlePaddle, specifically designed for the ERNIE series models, providing comprehensive training support.

Supported Training Scenarios:

• ✅ Supervised Fine-Tuning (SFT)


• ✅ LoRA Low-Rank Adaptation


• ✅ DPO Alignment Training


• ✅ Function Calling Training


• ✅ Multi-GPU Distributed Training

Quick Start Fine-tuning

Step 1: Download Model

huggingface-cli download baidu/ERNIE-4.5-VL-28B-A3B-Thinking \

  --local-dir baidu/ERNIE-4.5-VL-28B-A3B-Thinking

Step 2: Run SFT Training

# Basic SFT + LoRA (Recommended)

erniekit train examples/configs/ERNIE-4.5-VL-28B-A3B-Thinking/sft/run_sft_lora_8k.yaml



# Function calling specialized training

erniekit train examples/configs/ERNIE-4.5-VL-28B-A3B-Thinking/sft_function_call/run_sft_8k.yaml

Training Configuration Examples

LoRA Configuration Recommendations:

lora_config:

  r: 8                    # LoRA rank, higher means more expressive but more memory

  lora_alpha: 16          # LoRA scaling factor

  target_modules:         # Target modules for LoRA

    - q_proj

    - v_proj

    - k_proj

    - o_proj

  lora_dropout: 0.05      # Dropout rate

Training Hyperparameter Recommendations:

training_args:

  learning_rate: 1e-5     # Learning rate

  num_train_epochs: 3     # Number of epochs

  per_device_train_batch_size: 4

  gradient_accumulation_steps: 4

  warmup_ratio: 0.1       # Warmup ratio

  save_steps: 500         # Checkpoint save interval

  logging_steps: 10       # Logging interval

Data Preparation

Standard Data Format:

{

  "messages": [

    {

      "role": "user",

      "content": [

        {"type": "text", "text": "Describe this image"},

        {"type": "image_url", "image_url": {"url": "path/to/image.jpg"}}

      ]

    },

    {

      "role": "assistant",

      "content": "This is an image of..."

    }

  ]

}

Fine-tuning Best Practices

✅ Best Practices

1. 
   

   Data Quality First

   
   
   
   
   
   • Ensure correct training data format
   
   
   • Include high-quality image-text pairs
   
   
   • Sufficient data diversity
   
   
   • Avoid data bias
   
   
   
   


2. 
   

   LoRA Configuration Optimization

   
   
   
   
   
   • Resource-constrained: r=8, alpha=16
   
   
   • Balanced: r=16, alpha=32
   
   
   • High-quality: r=32, alpha=64
   
   
   
   


3. 
   

   Learning Rate Adjustment

   
   
   
   
   
   • Start with smaller learning rate (1e-5)
   
   
   • Use warmup to avoid training instability
   
   
   • Monitor loss curves and adjust timely
   
   
   
   


4. 
   

   Validation and Monitoring

   
   
   
   
   
   • Regular evaluation on validation set
   
   
   • Use early stopping to avoid overfitting
   
   
   • Track key metric changes
   
   
   
   


5. 
   

   Memory Optimization

   
   
   
   
   
   • Use gradient accumulation to reduce batch size
   
   
   • Enable mixed precision training
   
   
   • Consider using DeepSpeed ZeRO
   
   
   
   

Training Hardware Requirements

🤔 Frequently Asked Questions

Q1: How much GPU memory is required to run the model?

A:

• 
  Inference: At least 80GB GPU memory per card (e.g., A100 or H100)


• 
  Quantized Inference: Can be reduced to approximately 60GB using wint8 quantization


• 
  Fine-tuning (LoRA): Requires at least 40-80GB
  


• 
  Full Fine-tuning: Requires 160GB+, multi-GPU training recommended

Memory Optimization Suggestions:

• Use quantization techniques (wint8)


• Enable gradient checkpointing


• Reduce batch size


• Use LoRA instead of full fine-tuning

Q2: What languages does the model support?

A: The model is primarily optimized for Chinese and English, with the strongest understanding and generation capabilities in these two languages.

Language Support Details:

• 🟢 Chinese: Excellent (primary optimization language)


• 🟢 English: Excellent (primary optimization language)


• 🟡 Other Languages: Basic support, effectiveness may not match Chinese/English

Q3: How to enable "Thinking with Images" functionality?

A: "Thinking with Images" is automatically enabled when using tool-calling mode.

Enabling Method:

# Add parameters when starting vLLM

vllm serve baidu/ERNIE-4.5-VL-28B-A3B-Thinking \

  --trust-remote-code \

  --reasoning-parser ernie45 \

  --tool-call-parser ernie45 \

  --enable-auto-tool-choice

The model automatically determines when to:

• Zoom image details


• Search related images


• Call other tools

Q4: Can it be used commercially?

A: ✅ Yes, commercial use is allowed

The model is licensed under Apache 2.0, which permits:

• ✅ Commercial use


• ✅ Modification and distribution


• ✅ Patent use


• ✅ Private use

Important Notes:

• Retain copyright notices


• Mark significant modifications


• Comply with license terms

Q5: What advantages does it have compared to other multimodal models?

A: Key advantages include:

Q6: Does it support video input?

A: ✅ Full video understanding support

Video Processing Capabilities:

• Temporal information understanding


• Event localization


• Cross-frame content change recognition


• Video summary generation

Usage Method:

messages = [

    {

        "role": "user",

        "content": [

            {"type": "text", "text": "Describe what happens in the video"},

            {"type": "video", "video": "path/to/video.mp4"}

        ]

    }

]

image_inputs, video_inputs = processor.process_vision_info(messages)

Q7: How to achieve optimal inference performance?

A: Recommended configuration and optimization strategies:

Deployment Configuration:

vllm serve baidu/ERNIE-4.5-VL-28B-A3B-Thinking \

  --trust-remote-code \

  --dtype bfloat16 \

  --max-model-len 8192 \

  --max-num-seqs 32 \

  --gpu-memory-utilization 0.95 \

  --enable-chunked-prefill

Performance Optimization Recommendations:

1. 
   Use vLLM or FastDeploy instead of Transformers


2. 
   Enable bfloat16 precision for speed-accuracy balance


3. 
   Set concurrency appropriately adjust max-num-seqs based on memory


4. 
   Batch requests use batching mode for bulk inference


5. 
   Enable PagedAttention enabled by default in vLLM, improves memory efficiency


6. 
   Use quantization if memory-constrained, use wint8 quantization

Performance Benchmark Reference:

• Single inference latency: 200-500ms (depends on input length)


• Throughput: 20-50 requests/second (vLLM, single A100)


• Concurrency support: Up to 32 concurrent requests

Q8: How frequently is the model updated?

A: Baidu regularly updates the ERNIE series models.

Get Update Information:

• 📱 Hugging Face Model Page
  


• 📝 ERNIE Official Blog
  


• 💻 GitHub Repository
  

Recommendations:

• Follow official channels for latest versions


• Check Release Notes for improvements


• Validate compatibility in test environment before upgrading

Q9: How to handle inference errors or exceptions?

A: Common issues and solutions:

Out of Memory (OOM):

# Solution 1: Increase memory utilization

--gpu-memory-utilization 0.95



# Solution 2: Reduce concurrency

--max-num-seqs 16



# Solution 3: Use quantization

--quantization wint8

Loading Failure:

# Ensure trust_remote_code is added

--trust-remote-code



# Check network connection and model download integrity

huggingface-cli download baidu/ERNIE-4.5-VL-28B-A3B-Thinking --resume-download

Slow Inference:

• Check if using optimized inference framework (vLLM/FastDeploy)


• Verify GPU utilization is normal


• Consider using batch processing mode


• Check if input image resolution is too high

Q10: How to evaluate fine-tuning effectiveness?

A: Recommended methods for evaluating fine-tuned models:

1. Quantitative Evaluation:

# Calculate metrics on validation set

from sklearn.metrics import accuracy_score, f1_score



# For classification tasks

accuracy = accuracy_score(y_true, y_pred)

f1 = f1_score(y_true, y_pred, average='weighted')



# For generation tasks

from rouge import Rouge

rouge = Rouge()

scores = rouge.get_scores(predictions, references, avg=True)

2. Qualitative Evaluation:

• Manual inspection of generation quality


• Compare outputs before and after fine-tuning


• Test edge cases and difficult samples

3. Business Metrics:

• User satisfaction


• Task completion rate


• Error rate reduction

Summary and Recommendations

Core Advantages Summary

ERNIE-4.5-VL-28B-A3B-Thinking represents a significant breakthrough in multimodal AI:

🎯 Technical Innovation

• MoE architecture achieves parameter efficiency breakthrough


• Large-scale reinforcement learning enhances reasoning capabilities


• Innovative "Thinking with Images" feature


• Native tool calling support

⚡ Outstanding Performance

• 3B activated parameters achieve top-tier model performance


• 2-3x faster inference speed


• Significantly reduced memory footprint


• Leading performance across multiple benchmarks

🛠️ Comprehensive Features

• Visual reasoning and STEM problem solving


• Precise visual grounding capabilities


• Powerful video understanding


• Flexible tool calling mechanism

🚀 Flexible Deployment

• Multiple deployment options supported


• Quantization optimization lowers barriers


• Comprehensive documentation and examples


• Active community support

💼 Open Source Friendly

• Apache 2.0 license


• Commercial use supported


• Complete training toolchain


• Continuous version updates

Application Scenario Analysis

Related Resource Links

Official Channels:

• 🤖 ERNIE Bot Online
  


• 🤗 Hugging Face Model Page
  


• 💻 GitHub Repository
  


• 📝 Official Blog
  

ERNIE-4.5-VL-28B-A3B-Thinking Multimodal AI Model Complete Guide