Repository: huggingface/transformers
Pull request: updated visualBERT modelcard

# What does this PR do?

<!--
Congratulations! You've made it this far! You're not quite done yet though.

Once merged, your PR is going to appear in the release notes with the title you set, so make sure it's a great title that fully reflects the extent of your awesome contribution.

Then, please replace this with a description of the change and which issue is fixed (if applicable). Please also include relevant motivation and context. List any dependencies (if any) that are required for this change.

Once you're done, someone will review your PR shortly (see the section "Who can review?" below to tag some potential reviewers). They may suggest changes to make the code even better. If no one reviewed your PR after a week has passed, don't hesitate to post a new comment @-mentioning the same persons---sometimes notifications get lost.
-->

<!-- Remove if not applicable -->

Fixes # (issue)


## Before submitting
- [ ✓ ] This PR fixes a typo or improves the docs (you can dismiss the other checks if that's the case).
- [ ✓ ] Did you read the [contributor guideline](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md#create-a-pull-request),
      Pull Request section?
- [ ] Was this discussed/approved via a Github issue or the [forum](https://discuss.huggingface.co/)? Please add a link
      to it if that's the case.
- [ ] Did you make sure to update the documentation with your changes? Here are the
      [documentation guidelines](https://github.com/huggingface/transformers/tree/main/docs), and
      [here are tips on formatting docstrings](https://github.com/huggingface/transformers/tree/main/docs#writing-source-documentation).
- [ ] Did you write any new necessary tests?

@stevhliu would you please review my PR?


Changed files:
filename: docs/source/en/model_doc/visual_bert.md
patch: @@ -14,87 +14,116 @@ rendered properly in your Markdown viewer.
 
 -->
 
-# VisualBERT
-
-<div class="flex flex-wrap space-x-1">
-<img alt="PyTorch" src="https://img.shields.io/badge/PyTorch-DE3412?style=flat&logo=pytorch&logoColor=white">
+<div style="float: right;">
+    <div class="flex flex-wrap space-x-1">
+        <img alt="PyTorch" src="https://img.shields.io/badge/PyTorch-DE3412?style=flat&logo=pytorch&logoColor=white">
+    </div>
 </div>
 
-## Overview
-
-The VisualBERT model was proposed in [VisualBERT: A Simple and Performant Baseline for Vision and Language](https://huggingface.co/papers/1908.03557) by Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, Kai-Wei Chang.
-VisualBERT is a neural network trained on a variety of (image, text) pairs.
-
-The abstract from the paper is the following:
-
-*We propose VisualBERT, a simple and flexible framework for modeling a broad range of vision-and-language tasks.
-VisualBERT consists of a stack of Transformer layers that implicitly align elements of an input text and regions in an
-associated input image with self-attention. We further propose two visually-grounded language model objectives for
-pre-training VisualBERT on image caption data. Experiments on four vision-and-language tasks including VQA, VCR, NLVR2,
-and Flickr30K show that VisualBERT outperforms or rivals with state-of-the-art models while being significantly
-simpler. Further analysis demonstrates that VisualBERT can ground elements of language to image regions without any
-explicit supervision and is even sensitive to syntactic relationships, tracking, for example, associations between
-verbs and image regions corresponding to their arguments.*
-
-This model was contributed by [gchhablani](https://huggingface.co/gchhablani). The original code can be found [here](https://github.com/uclanlp/visualbert).
-
-## Usage tips
-
-1. Most of the checkpoints provided work with the [`VisualBertForPreTraining`] configuration. Other
-   checkpoints provided are the fine-tuned checkpoints for down-stream tasks - VQA ('visualbert-vqa'), VCR
-   ('visualbert-vcr'), NLVR2 ('visualbert-nlvr2'). Hence, if you are not working on these downstream tasks, it is
-   recommended that you use the pretrained checkpoints.
-
-2. For the VCR task, the authors use a fine-tuned detector for generating visual embeddings, for all the checkpoints.
-   We do not provide the detector and its weights as a part of the package, but it will be available in the research
-   projects, and the states can be loaded directly into the detector provided.
-
-VisualBERT is a multi-modal vision and language model. It can be used for visual question answering, multiple choice,
-visual reasoning and region-to-phrase correspondence tasks. VisualBERT uses a BERT-like transformer to prepare
-embeddings for image-text pairs. Both the text and visual features are then projected to a latent space with identical
-dimension.
-
-To feed images to the model, each image is passed through a pre-trained object detector and the regions and the
-bounding boxes are extracted. The authors use the features generated after passing these regions through a pre-trained
-CNN like ResNet as visual embeddings. They also add absolute position embeddings, and feed the resulting sequence of
-vectors to a standard BERT model. The text input is concatenated in the front of the visual embeddings in the embedding
-layer, and is expected to be bound by [CLS] and a [SEP] tokens, as in BERT. The segment IDs must also be set
-appropriately for the textual and visual parts.
-
-The [`BertTokenizer`] is used to encode the text. A custom detector/image processor must be used
-to get the visual embeddings. The following example notebooks show how to use VisualBERT with Detectron-like models:
-
-- [VisualBERT VQA demo notebook](https://github.com/huggingface/transformers-research-projects/tree/main/visual_bert) : This notebook
-  contains an example on VisualBERT VQA.
+# VisualBERT
 
-- [Generate Embeddings for VisualBERT (Colab Notebook)](https://colab.research.google.com/drive/1bLGxKdldwqnMVA5x4neY7-l_8fKGWQYI?usp=sharing) : This notebook contains
-  an example on how to generate visual embeddings.
+[VisualBERT](https://huggingface.co/papers/1908.03557) is a vision-and-language model. It uses an approach called "early fusion", where inputs are fed together into a single Transformer stack initialized from [BERT](./bert). Self-attention implicitly aligns words with their corresponding image objects. It processes text with visual features from object-detector regions instead of raw pixels.
+
+You can find all the original VisualBERT checkpoints under the [UCLA NLP](https://huggingface.co/uclanlp/models?search=visualbert) organization.
+
+
+> [!TIP]
+> This model was contributed by [gchhablani](https://huggingface.co/gchhablani).
+> Click on the VisualBERT models in the right sidebar for more examples of how to apply VisualBERT to different image and language tasks.
+
+The example below demonstrates how to answer a question based on an image with the [`AutoModel`] class.
+
+<hfoptions id="usage">
+<hfoption id="AutoModel">
+
+```py
+import torch
+import torchvision
+from PIL import Image
+import numpy as np
+from transformers import AutoTokenizer, VisualBertForQuestionAnswering
+import requests
+from io import BytesIO
+
+def get_visual_embeddings_simple(image, device=None):
+    
+    model = torchvision.models.resnet50(pretrained=True)
+    model = torch.nn.Sequential(*list(model.children())[:-1])
+    model.to(device)
+    model.eval()
+    
+    transform = torchvision.transforms.Compose([
+        torchvision.transforms.Resize(256),
+        torchvision.transforms.CenterCrop(224),
+        torchvision.transforms.ToTensor(),
+        torchvision.transforms.Normalize(
+            mean=[0.485, 0.456, 0.406],
+            std=[0.229, 0.224, 0.225]
+        )
+    ])
+    
+    if isinstance(image, str):
+        image = Image.open(image).convert('RGB')
+    elif isinstance(image, Image.Image):
+        image = image.convert('RGB')
+    else:
+        raise ValueError("Image must be a PIL Image or path to image file")
+    
+    image_tensor = transform(image).unsqueeze(0).to(device)
+    
+    with torch.no_grad():
+        features = model(image_tensor)
+    
+    batch_size = features.shape[0]
+    feature_dim = features.shape[1]
+    visual_seq_length = 10
+    
+    visual_embeds = features.squeeze(-1).squeeze(-1).unsqueeze(1).expand(batch_size, visual_seq_length, feature_dim)
+    
+    return visual_embeds
+
+tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
+model = VisualBertForQuestionAnswering.from_pretrained("uclanlp/visualbert-vqa-coco-pre")
+
+response = requests.get("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg")
+image = Image.open(BytesIO(response.content))
+    
+visual_embeds = get_visual_embeddings_simple(image)
+    
+inputs = tokenizer("What is shown in this image?", return_tensors="pt")
+    
+visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
+visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)
+    
+inputs.update({
+    "visual_embeds": visual_embeds,
+    "visual_token_type_ids": visual_token_type_ids,
+    "visual_attention_mask": visual_attention_mask,
+})
+    
+with torch.no_grad():
+    outputs = model(**inputs)
+    logits = outputs.logits
+    predicted_answer_idx = logits.argmax(-1).item()
+
+print(f"Predicted answer: {predicted_answer_idx}")
+```
 
-The following example shows how to get the last hidden state using [`VisualBertModel`]:
+</hfoption>
+</hfoptions>
 
-```python
->>> import torch
->>> from transformers import BertTokenizer, VisualBertModel
+## Notes
 
->>> model = VisualBertModel.from_pretrained("uclanlp/visualbert-vqa-coco-pre")
->>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
+- Use a fine-tuned checkpoint for downstream tasks, like `visualbert-vqa` for visual question answering. Otherwise, use one of the pretrained checkpoints.
+- The fine-tuned detector and weights aren't provided (available in the research projects), but the states can be directly loaded into the detector.
+- The text input is concatenated in front of the visual embeddings in the embedding layer and is expected to be bound by `[CLS]` and [`SEP`] tokens.
+- The segment ids must be set appropriately for the text and visual parts.
+- Use [`BertTokenizer`] to encode the text and implement a custom detector/image processor to get the visual embeddings.
 
->>> inputs = tokenizer("What is the man eating?", return_tensors="pt")
->>> # this is a custom function that returns the visual embeddings given the image path
->>> visual_embeds = get_visual_embeddings(image_path)
+## Resources
 
->>> visual_token_type_ids = torch.ones(visual_embeds.shape[:-1], dtype=torch.long)
->>> visual_attention_mask = torch.ones(visual_embeds.shape[:-1], dtype=torch.float)
->>> inputs.update(
-...     {
-...         "visual_embeds": visual_embeds,
-...         "visual_token_type_ids": visual_token_type_ids,
-...         "visual_attention_mask": visual_attention_mask,
-...     }
-... )
->>> outputs = model(**inputs)
->>> last_hidden_state = outputs.last_hidden_state
-```
+- Refer to this [notebook](https://github.com/huggingface/transformers-research-projects/tree/main/visual_bert) for an example of using VisualBERT for visual question answering.
+- Refer to this [notebook](https://colab.research.google.com/drive/1bLGxKdldwqnMVA5x4neY7-l_8fKGWQYI?usp=sharing) for an example of how to generate visual embeddings.
 
 ## VisualBertConfig