GLM-5.2 is live. #1 throughput on OpenRouter, pay-per-token on FriendliAI. Try it today ➜
unsloth
Available on FriendliAI
Run this model inference on single tenant GPU with unmatched speed and reliability at scale.
Model Details
Model Provider
unsloth
Model Tree
ibm-granite/granite-vision-3.2-2b
Input Modalities
Output Modalities
Supported Functionality
Granite Vision model is supported natively transformers>=4.49. Below is a simple example of how to use the granite-vision-3.2-2b model.
transformersFirst, make sure to build the latest verions of transormers:
shell
pip install transformers>=4.49
Then run the code:
python
from transformers import AutoProcessor, AutoModelForVision2Seqfrom huggingface_hub import hf_hub_downloadimport torchdevice = "cuda" if torch.cuda.is_available() else "cpu"model_path = "ibm-granite/granite-vision-3.2-2b"processor = AutoProcessor.from_pretrained(model_path)model = AutoModelForVision2Seq.from_pretrained(model_path).to(device)# prepare image and text prompt, using the appropriate prompt templateimg_path = hf_hub_download(repo_id=model_path, filename='example.png')conversation = [{"role": "user","content": [{"type": "image", "url": img_path},{"type": "text", "text": "What is the highest scoring model on ChartQA and what is its score?"},],},]inputs = processor.apply_chat_template(conversation,add_generation_prompt=True,tokenize=True,return_dict=True,return_tensors="pt").to(device)# autoregressively complete promptoutput = model.generate(**inputs, max_new_tokens=100)print(processor.decode(output[0], skip_special_tokens=True))
The model can also be loaded with vLLM. First make sure to install the following libraries:
shell
pip install torch torchvision torchaudiopip install vllm==0.6.6
Then, copy the snippet from the section that is relevant for your use case.
python
from vllm import LLM, SamplingParamsfrom vllm.assets.image import ImageAssetfrom huggingface_hub import hf_hub_downloadfrom PIL import Imagemodel_path = "ibm-granite/granite-vision-3.2-2b"model = LLM(model=model_path,limit_mm_per_prompt={"image": 1},)sampling_params = SamplingParams(temperature=0.2,max_tokens=64,)# Define the question we want to answer and format the promptimage_token = "<image>"system_prompt = "<|system|>\nA chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions.\n"question = "What is the highest scoring model on ChartQA and what is its score?"prompt = f"{system_prompt}<|user|>\n{image_token}\n{question}\n<|assistant|>\n"img_path = hf_hub_download(repo_id=model_path, filename='example.png')image = Image.open(img_path).convert("RGB")print(image)# Build the inputs to vLLM; the image is passed as `multi_modal_data`.inputs = {"prompt": prompt,"multi_modal_data": {"image": image,}}outputs = model.generate(inputs, sampling_params=sampling_params)print(f"Generated text: {outputs[0].outputs[0].text}")
For an example of fine-tuning Granite Vision for new tasks refer to this notebook.
For an example of MM RAG using granite vision refer to this notebook.
Model Architecture:
The architecture of granite-vision-3.2-2b consists of the following components:
(1) Vision encoder: SigLIP (https://huggingface.co/docs/transformers/en/model_doc/siglip).
(2) Vision-language connector: two-layer MLP with gelu activation function.
(3) Large language model: granite-3.1-2b-instruct with 128k context length (https://huggingface.co/ibm-granite/granite-3.1-2b-instruct).
We built upon LLaVA (https://llava-vl.github.io) to train our model. We use multi-layer encoder features and a denser grid resolution in AnyRes to enhance the model's ability to understand nuanced visual content, which is essential for accurately interpreting document images.
Training Data:
Overall, our training data is largely comprised of two key sources: (1) publicly available datasets (2) internally created synthetic data targeting specific capabilities including document understanding tasks. A detailed attribution of datasets can be found in the technical report.
Infrastructure: We train Granite Vision using IBM's super computing cluster, Blue Vela, which is outfitted with NVIDIA H100 GPUs. This cluster provides a scalable and efficient infrastructure for training our models over thousands of GPUs.
Ethical Considerations and Limitations: The use of Large Vision and Language Models involves risks and ethical considerations people must be aware of, including but not limited to: bias and fairness, misinformation, and autonomous decision-making. granite-vision-3.2-2b is not the exception in this regard. Although our alignment processes include safety considerations, the model may in some cases produce inaccurate, biased, or unsafe responses to user prompts. Additionally, it remains uncertain whether smaller models might exhibit increased susceptibility to hallucination in generation scenarios due to their reduced sizes, which could limit their ability to generate coherent and contextually accurate responses. This aspect is currently an active area of research, and we anticipate more rigorous exploration, comprehension, and mitigations in this domain. Regarding ethics, a latent risk associated with all Large Language Models is their malicious utilization. We urge the community to use granite-vision-3.2-2b with ethical intentions and in a responsible way. We recommend using this model for document understanding tasks, and note that more general vision tasks may pose higher inherent risks of triggering biased or harmful output. To enhance safety, we recommend using granite-vision-3.2-2b alongside Granite Guardian. Granite Guardian is a fine-tuned instruct model designed to detect and flag risks in prompts and responses across key dimensions outlined in the IBM AI Risk Atlas. Its training, which includes both human-annotated and synthetic data informed by internal red-teaming, enables it to outperform similar open-source models on standard benchmarks, providing an additional layer of safety.
Resources