Skip to content

Commit c9fcbd5

Browse files
1himanstevhliu
1himan
and
stevhliu
authored
Updated the Model docs - for the ALIGN model (#38072)
* Updated the Model docs - for the ALIGN model * Update docs/source/en/model_doc/align.md Co-authored-by: Steven Liu <[email protected]> * Update docs/source/en/model_doc/align.md Co-authored-by: Steven Liu <[email protected]> * Updated align.md * Update docs/source/en/model_doc/align.md Co-authored-by: Steven Liu <[email protected]> * Update docs/source/en/model_doc/align.md Co-authored-by: Steven Liu <[email protected]> * Update align.md * fix --------- Co-authored-by: Steven Liu <[email protected]>
1 parent cba94e9 commit c9fcbd5

File tree

1 file changed

+112
-36
lines changed

1 file changed

+112
-36
lines changed

‎docs/source/en/model_doc/align.md

Lines changed: 112 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -13,65 +13,141 @@ specific language governing permissions and limitations under the License.
1313
rendered properly in your Markdown viewer.
1414
1515
-->
16+
<div style="float: right;">
17+
<div class="flex flex-wrap space-x-1">
18+
<img alt="PyTorch" src="https://img.shields.io/badge/PyTorch-DE3412?style=flat&logo=pytorch&logoColor=white">
19+
<img alt="Transformers" src="https://img.shields.io/badge/Transformers-6B5B95?style=flat&logo=transformers&logoColor=white">
20+
</div>
21+
</div>
1622

1723
# ALIGN
1824

19-
<div class="flex flex-wrap space-x-1">
20-
<img alt="PyTorch" src="https://img.shields.io/badge/PyTorch-DE3412?style=flat&logo=pytorch&logoColor=white">
21-
</div>
22-
23-
## Overview
25+
[ALIGN](https://huggingface.co/papers/2102.05918) is pretrained on a noisy 1.8 billion alt‑text and image pair dataset to show that scale can make up for the noise. It uses a dual‑encoder architecture, [EfficientNet](./efficientnet) for images and [BERT](./bert) for text, and a contrastive loss to align similar image–text embeddings together while pushing different embeddings apart. Once trained, ALIGN can encode any image and candidate captions into a shared vector space for zero‑shot retrieval or classification without requiring extra labels. This scale‑first approach reduces dataset curation costs and powers state‑of‑the‑art image–text retrieval and zero‑shot ImageNet classification.
2426

25-
The ALIGN model was proposed in [Scaling Up Visual and Vision-Language Representation Learning With Noisy Text Supervision](https://arxiv.org/abs/2102.05918) by Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc V. Le, Yunhsuan Sung, Zhen Li, Tom Duerig. ALIGN is a multi-modal vision and language model. It can be used for image-text similarity and for zero-shot image classification. ALIGN features a dual-encoder architecture with [EfficientNet](efficientnet) as its vision encoder and [BERT](bert) as its text encoder, and learns to align visual and text representations with contrastive learning. Unlike previous work, ALIGN leverages a massive noisy dataset and shows that the scale of the corpus can be used to achieve SOTA representations with a simple recipe.
27+
You can find all the original ALIGN checkpoints under the [Kakao Brain](https://huggingface.co/kakaobrain?search_models=align) organization.
2628

27-
The abstract from the paper is the following:
29+
> [!TIP]
30+
> Click on the ALIGN models in the right sidebar for more examples of how to apply ALIGN to different vision and text related tasks.
2831
29-
*Pre-trained representations are becoming crucial for many NLP and perception tasks. While representation learning in NLP has transitioned to training on raw text without human annotations, visual and vision-language representations still rely heavily on curated training datasets that are expensive or require expert knowledge. For vision applications, representations are mostly learned using datasets with explicit class labels such as ImageNet or OpenImages. For vision-language, popular datasets like Conceptual Captions, MSCOCO, or CLIP all involve a non-trivial data collection (and cleaning) process. This costly curation process limits the size of datasets and hence hinders the scaling of trained models. In this paper, we leverage a noisy dataset of over one billion image alt-text pairs, obtained without expensive filtering or post-processing steps in the Conceptual Captions dataset. A simple dual-encoder architecture learns to align visual and language representations of the image and text pairs using a contrastive loss. We show that the scale of our corpus can make up for its noise and leads to state-of-the-art representations even with such a simple learning scheme. Our visual representation achieves strong performance when transferred to classification tasks such as ImageNet and VTAB. The aligned visual and language representations enables zero-shot image classification and also set new state-of-the-art results on Flickr30K and MSCOCO image-text retrieval benchmarks, even when compared with more sophisticated cross-attention models. The representations also enable cross-modality search with complex text and text + image queries.*
32+
The example below demonstrates zero-shot image classification with [`Pipeline`] or the [`AutoModel`] class.
3033

31-
This model was contributed by [Alara Dirik](https://huggingface.co/adirik).
32-
The original code is not released, this implementation is based on the Kakao Brain implementation based on the original paper.
34+
<hfoptions id="usage">
3335

34-
## Usage example
36+
<hfoption id="Pipeline">
3537

36-
ALIGN uses EfficientNet to get visual features and BERT to get the text features. Both the text and visual features are then projected to a latent space with identical dimension. The dot product between the projected image and text features is then used as a similarity score.
38+
```py
39+
import torch
40+
from transformers import pipeline
41+
42+
pipeline = pipeline(
43+
task="zero-shot-image-classification",
44+
model="kakaobrain/align-base",
45+
device=0,
46+
torch_dtype=torch.bfloat16
47+
)
48+
49+
candidate_labels = [
50+
"a photo of a dog",
51+
"a photo of a cat",
52+
"a photo of a person"
53+
]
54+
55+
pipeline("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg", candidate_labels=candidate_labels)
56+
```
3757

38-
[`AlignProcessor`] wraps [`EfficientNetImageProcessor`] and [`BertTokenizer`] into a single instance to both encode the text and preprocess the images. The following example shows how to get the image-text similarity scores using [`AlignProcessor`] and [`AlignModel`].
58+
</hfoption>
59+
<hfoption id="AutoModel">
3960

40-
```python
41-
import requests
61+
```py
4262
import torch
63+
import requests
4364
from PIL import Image
44-
from transformers import AlignProcessor, AlignModel
65+
from transformers import AutoProcessor, AutoModelForZeroShotImageClassification
4566

46-
processor = AlignProcessor.from_pretrained("kakaobrain/align-base")
47-
model = AlignModel.from_pretrained("kakaobrain/align-base")
67+
processor = AutoProcessor.from_pretrained("kakaobrain/align-base")
68+
model = AutoModelForZeroShotImageClassification.from_pretrained("kakaobrain/align-base").to("cuda")
4869

49-
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
50-
image = Image.open(requests.get(url, stream=True).raw)
51-
candidate_labels = ["an image of a cat", "an image of a dog"]
52-
53-
inputs = processor(images=image ,text=candidate_labels, return_tensors="pt")
70+
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
71+
image = requests.get(url, stream=True)
72+
inputs = Image.open(image.raw).convert("RGB")
5473

74+
image_inputs = processor(images=inputs, return_tensors="pt").to("cuda")
5575
with torch.no_grad():
56-
outputs = model(**inputs)
76+
image_embeds = model.get_image_features(**image_inputs)
5777

58-
# this is the image-text similarity score
59-
logits_per_image = outputs.logits_per_image
78+
candidate_labels = ["a photo of a dog", "a photo of a cat", "a photo of a person"]
79+
text_inputs = processor(text=candidate_labels, padding=True, return_tensors="pt").to("cuda")
80+
with torch.no_grad():
81+
text_embeds = model.get_text_features(**text_inputs)
6082

61-
# we can take the softmax to get the label probabilities
62-
probs = logits_per_image.softmax(dim=1)
63-
print(probs)
64-
```
83+
image_embeds = image_embeds / image_embeds.norm(p=2, dim=-1, keepdim=True)
84+
text_embeds = text_embeds / text_embeds.norm(p=2, dim=-1, keepdim=True)
6585

66-
## Resources
86+
logits = (image_embeds @ text_embeds.T) * 100.0
87+
probs = logits.softmax(dim=-1).cpu().squeeze()
6788

68-
A list of official Hugging Face and community (indicated by 🌎) resources to help you get started with ALIGN.
89+
for label, score in zip(candidate_labels, probs):
90+
print(f"{label:20s} → {score.item():.4f}")
91+
```
6992

70-
- A blog post on [ALIGN and the COYO-700M dataset](https://huggingface.co/blog/vit-align).
71-
- A zero-shot image classification [demo](https://huggingface.co/spaces/adirik/ALIGN-zero-shot-image-classification).
72-
- [Model card](https://huggingface.co/kakaobrain/align-base) of `kakaobrain/align-base` model.
93+
</hfoption>
94+
95+
</hfoptions>
96+
97+
## Notes
98+
99+
- ALIGN projects the text and visual features into latent space and the dot product between the projected image and text features is used as the similarity score. The example below demonstrates how to calculate the image-text similarity score with [`AlignProcessor`] and [`AlignModel`].
100+
101+
```py
102+
# Example of using ALIGN for image-text similarity
103+
from transformers import AlignProcessor, AlignModel
104+
import torch
105+
from PIL import Image
106+
import requests
107+
from io import BytesIO
108+
109+
# Load processor and model
110+
processor = AlignProcessor.from_pretrained("kakaobrain/align-base")
111+
model = AlignModel.from_pretrained("kakaobrain/align-base")
112+
113+
# Download image from URL
114+
url = "https://huggingface.co/roschmid/dog-races/resolve/main/images/Golden_Retriever.jpg"
115+
response = requests.get(url)
116+
image = Image.open(BytesIO(response.content)) # Convert the downloaded bytes to a PIL Image
117+
118+
texts = ["a photo of a cat", "a photo of a dog"]
119+
120+
# Process image and text inputs
121+
inputs = processor(images=image, text=texts, return_tensors="pt")
122+
123+
# Get the embeddings
124+
with torch.no_grad():
125+
outputs = model(**inputs)
126+
127+
image_embeds = outputs.image_embeds
128+
text_embeds = outputs.text_embeds
129+
130+
# Normalize embeddings for cosine similarity
131+
image_embeds = image_embeds / image_embeds.norm(dim=1, keepdim=True)
132+
text_embeds = text_embeds / text_embeds.norm(dim=1, keepdim=True)
133+
134+
# Calculate similarity scores
135+
similarity_scores = torch.matmul(text_embeds, image_embeds.T)
136+
137+
# Print raw scores
138+
print("Similarity scores:", similarity_scores)
139+
140+
# Convert to probabilities
141+
probs = torch.nn.functional.softmax(similarity_scores, dim=0)
142+
print("Probabilities:", probs)
143+
144+
# Get the most similar text
145+
most_similar_idx = similarity_scores.argmax().item()
146+
print(f"Most similar text: '{texts[most_similar_idx]}'")
147+
```
73148

74-
If you're interested in submitting a resource to be included here, please feel free to open a Pull Request and we will review it. The resource should ideally demonstrate something new instead of duplicating an existing resource.
149+
## Resources
150+
- Refer to the [Kakao Brain’s Open Source ViT, ALIGN, and the New COYO Text-Image Dataset](https://huggingface.co/blog/vit-align) blog post for more details.
75151

76152
## AlignConfig
77153

0 commit comments

Comments
 (0)