Paligemma2 3b Pt 896

🚀 PaliGemma 2 model card

PaliGemma 2 is a vision - language model (VLM) that takes both images and text as input and generates text output. It supports multiple languages and is designed for excellent fine - tune performance in various vision - language tasks.

Model page: PaliGemma

Transformers PaliGemma 2 3B weights are pre - trained with 896*896 input images and 512 token input/output text sequences. The model is available in the bfloat16 format for fine - tuning.

Resources and technical documentation:

• PaliGemma 2 on Kaggle
• Responsible Generative AI Toolkit

Terms of Use: Terms

Authors: Google

🚀 Quick Start

To access PaliGemma on Hugging Face, you’re required to review and agree to Google’s usage license. To do this, please ensure you’re logged - in to Hugging Face and click the "Acknowledge license" button below. Requests are processed immediately.

✨ Features

Model information

Model summary

PaliGemma 2 is an update of the PaliGemma vision - language model (VLM) which incorporates the capabilities of the Gemma 2 models. The PaliGemma family of models is inspired by PaLI - 3 and based on open components such as the SigLIP vision model and Gemma 2 language models. It takes both image and text as input and generates text as output, supporting multiple languages. It is designed for class - leading fine - tune performance on a wide range of vision - language tasks such as image and short video caption, visual question answering, text reading, object detection and object segmentation.

Model architecture

PaliGemma 2 is the composition of a Transformer decoder and a Vision Transformer image encoder. The text decoder is initialized from Gemma 2 in the 2B, 9B, and 27B parameter sizes. The image encoder is initialized from [SigLIP - So400m/14](https://colab.research.google.com/github/google - research/big_vision/blob/main/big_vision/configs/proj/image_text/SigLIP_demo.ipynb). Similar to the original PaliGemma model, PaliGemma 2 is trained following the PaLI - 3 recipes.

Inputs and outputs

• Input: Image and text string, such as a prompt to caption the image, or a question.
• Output: Generated text in response to the input, such as a caption of the image, an answer to a question, a list of object bounding box coordinates, or segmentation codewords.

Citation

@article{
    title={PaliGemma 2: A Family of Versatile VLMs for Transfer},
    author={Andreas Steiner and André Susano Pinto and Michael Tschannen and Daniel Keysers and Xiao Wang and Yonatan Bitton and Alexey Gritsenko and Matthias Minderer and Anthony Sherbondy and Shangbang Long and Siyang Qin and Reeve Ingle and Emanuele Bugliarello and Sahar Kazemzadeh and Thomas Mesnard and Ibrahim Alabdulmohsin and Lucas Beyer and Xiaohua Zhai},
    year={2024},
    journal={arXiv preprint arXiv:2412.03555}
}

Model data

Pre - train datasets

PaliGemma 2 is pre - trained on the following mixture of datasets:

• WebLI: WebLI (Web Language Image) is a web - scale multilingual image - text dataset built from the public web. A wide range of WebLI splits are used to acquire versatile model capabilities, such as visual semantic understanding, object localization, visually - situated text understanding, and multilinguality.
• CC3M - 35L: Curated English image - alt_text pairs from webpages (Sharma et al., 2018). The Google Cloud Translation API is used to translate into 34 additional languages.
• VQ²A - CC3M - 35L/VQG - CC3M - 35L: A subset of VQ2A - CC3M (Changpinyo et al., 2022a), translated into the same additional 34 languages as CC3M - 35L, using the Google Cloud Translation API.
• OpenImages: Detection and object - aware questions and answers (Piergiovanni et al. 2022) generated by handcrafted rules on the OpenImages dataset.
• WIT: Images and texts collected from Wikipedia (Srinivasan et al., 2021).

PaliGemma 2 is based on Gemma 2, and you can find information on the pre - training datasets for Gemma 2 in the Gemma 2 model card.

Data responsibility filtering

The following filters are applied to WebLI, with the goal of training PaliGemma 2 on safe and responsible data:

• Pornographic image filtering: This filter removes images deemed to be of pornographic nature.
• Text safety filtering: Images paired with unsafe text are identified and filtered out. Unsafe text is any text deemed to contain or be about child sexual abuse imagery (CSAI), pornography, vulgarities, or is otherwise offensive.
• Text toxicity filtering: The Perspective API is further used to identify and filter out images paired with text deemed insulting, obscene, hateful or otherwise toxic.
• Text personal information filtering: Certain personal information and other sensitive data are filtered using the Cloud Data Loss Prevention (DLP) API to protect the privacy of individuals. Identifiers such as social security numbers and [other sensitive information types] are removed.
• Additional methods: Filtering based on content quality and safety in line with our policies and practices.

[other sensitive information types]: https://cloud.google.com/sensitive-data-protection/docs/high - sensitivity - infotypes - reference?_gl=1jg604m_gaODk5MzA3ODQyLjE3MTAzMzQ3NTk._ga_WH2QY8WWF5*MTcxMDUxNTkxMS4yLjEuMTcxMDUxNjA2NC4wLjAuMA..&_ga=2.172110058.-899307842.1710334759

💻 Usage Examples

Basic Usage

The following snippet uses model google/paligemma2-3b-pt-896 for reference purposes. It is a base model and is recommended to use after fine - tuning it on a downstream task.

Here is a [notebook](https://github.com/merveenoyan/smol - vision/blob/main/Fine_tune_PaliGemma.ipynb) that showcases fine - tuning PaliGemma 2.

from transformers import (
    PaliGemmaProcessor,
    PaliGemmaForConditionalGeneration,
)
from transformers.image_utils import load_image
import torch

model_id = "google/paligemma2-3b-pt-896"

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg"
image = load_image(url)

model = PaliGemmaForConditionalGeneration.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map="auto").eval()
processor = PaliGemmaProcessor.from_pretrained(model_id)

# Leaving the prompt blank for pre - trained models
prompt = ""
model_inputs = processor(text=prompt, images=image, return_tensors="pt").to(torch.bfloat16).to(model.device)
input_len = model_inputs["input_ids"].shape[-1]

with torch.inference_mode():
    generation = model.generate(**model_inputs, max_new_tokens=100, do_sample=False)
    generation = generation[0][input_len:]
    decoded = processor.decode(generation, skip_special_tokens=True)
    print(decoded)

🔧 Technical Details

Hardware

PaliGemma 2 was trained using the latest generation of Tensor Processing Unit (TPU) hardware (TPUv5e).

Software

Training was completed using JAX, Flax, TFDS and [big_vision](https://github.com/google - research/big_vision).

JAX allows researchers to take advantage of the latest generation of hardware, including TPUs, for faster and more efficient training of large models.

TFDS is used to access datasets and Flax is used for model architecture. The PaliGemma 2 fine - tune code and inference code are released in the big_vision GitHub repository.

📚 Documentation

Benchmark results

In order to verify the transferability of PaliGemma 2 to a wide variety of academic tasks, we fine - tune the pretrained models on each task. We report results on different resolutions to provide an impression of which tasks benefit from increased resolution. Importantly, none of these tasks or datasets are part of the pretraining data mixture, and their images are explicitly removed from the web - scale pre - training data.

PaliGemma 2 results by model resolution and size

Additional Benchmarks

[ICDAR 2015 Incidental][icdar2015 - inc]

[Total - Text][total - text]

[FinTabNet][fintabnet]

[PubTabNet][pubtabnet]

[GrandStaff][grandstaff]

[PubChem][pubchem]

• PaliGemma 2 3B, Full Match: 94.8

[DOCCI][docci]

• avg#char: Average number of characters
• avg#sent: Average number of sentences
• NES: Non entailment sentences

[MIMIC - CXR][mimic - cxr]

[Visual Spatial Reasoning][vsr]

Evaluation approach

Our evaluation methods include structured ethics and safety evaluations across relevant content policies, including:

• Human evaluation on prompts covering child safety, content safety and representational harms. See the Gemma model card for more details on evaluation approach, but with image captioning and visual question answering setups.
• Image - to - Text benchmark evaluation: Benchmark against relevant academic datasets such as FairFace Dataset (Karkkainen et al., 2021).

Evaluation results

• The human evaluation results of ethics and safety evaluations are within acceptable thresholds for meeting [internal policies](https://storage.googleapis.com/gweb - uniblog - publish - prod/documents/2023_Google_AI_Principles_Progress_Update.pdf#page=11) for categories such as child safety, content safety and representational harms.
• On top of robust internal evaluations, we also use the Perspective API (threshold of 0.8) to measure toxicity, profanity, and other potential issues in the generated captions for images sourced from the FairFace dataset. We report the maximum and median values observed across subgroups for each of the perceived gender, ethnicity, and age attributes.

Intended usage

Open Vision Language Models (VLMs) have a wide range of applications across various industries and domains.