Babel-ImageNet: Massively Multilingual Evaluation of Vision-and-Language Representations (2024)

Abstract: Vision-and-language (VL) models with separate encoders for each modality (e.g., CLIP) have become the go-to models for zero-shot image classification and image-text retrieval. They are, however, mostly evaluated in English as multilingual benchmarks are limited in availability. We introduce Babel-ImageNet, a massively multilingual benchmark that offers (partial) translations of ImageNet labels to 100 languages, built without machine translation or manual annotation. We instead automatically obtain reliable translations by linking them – via shared WordNet synsets – to BabelNet, a massively multilingual lexico-semantic network. We evaluate 11 public multilingual CLIP models on zero-shot image classification (ZS-IC) on our benchmark, demonstrating a significant gap between English ImageNet performance and that of high-resource languages (e.g., German or Chinese), and an even bigger gap for low-resource languages (e.g., Sinhala or Lao). Crucially, we show that the models’ ZS-IC performance highly correlates with their performance in image-text retrieval, validating the use of Babel-ImageNet to evaluate multilingual models for the vast majority of languages without gold image-text data. Finally, we show that the performance of multilingual CLIP can be drastically improved for low-resource languages with parameter-efficient languagespecific training. We make our code and data publicly available: https://github. com/gregor-ge/Babel-ImageNet

text: Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 5064–5084 August 11-16, 2024 ©2024 Association for Computational Linguistics
Vision-and-language (VL) models with separate encoders for each modality (e.g., CLIP) have become the go-to models for zero-shot image classification and image-text retrieval. They are, however, mostly evaluated in English as multilingual benchmarks are limited in availability. We introduce Babel-ImageNet, a massively multilingual benchmark that offers (partial) translations of ImageNet labels to 100 languages, built without machine translation or manual annotation. We instead automatically obtain reliable translations by linking them – via shared WordNet synsets – to BabelNet, a massively multilingual lexico-semantic network. We evaluate 11 public multilingual CLIP models on zero-shot image classification (ZS-IC) on our benchmark, demonstrating a significant gap between English ImageNet performance and that of high-resource languages (e.g., German or Chinese), and an even bigger gap for low-resource languages (e.g., Sinhala or Lao). Crucially, we show that the models’ ZS-IC performance highly correlates with their performance in image-text retrieval, validating the use of Babel-ImageNet to evaluate multilingual models for the vast majority of languages without gold image-text data. Finally, we show that the performance of multilingual CLIP can be drastically improved for low-resource languages with parameter-efficient languagespecific training. We make our code and data publicly available: https://github. com/gregor-ge/Babel-ImageNet

heading: 1 Introduction
text: CLIP models (Radford et al., 2021; Jia et al., 2021; Pham et al., 2021) have become widely used visionand-language (VL) models, owing popularity to efficient inference based on separate yet semantically aligned encoders for the two modalities. Their bi-encoder architecture makes them ideal for efficient image-text retrieval (Lin et al., 2014; Plummer et al., 2015) and zero-shot image classifica-
tion (Radford et al., 2021), or to produce downstream features for supervised tasks such as image generation (Rombach et al., 2022) or cross-modal reasoning (Eichenberg et al., 2022; Li et al., 2023).
Motivated by the observation that performance on ImageNet classification translates well to performance in many other image tasks (Recht et al., 2019; Fang et al., 2023), CLIP models are typically evaluated on zero-shot image classification (ZS-IC), i.e., by comparing the representation of an image with text representations of class labels, whereby ImageNet (Deng et al., 2009) is the most prominent benchmark. With ImageNet class labels available only in English, this supports only evaluation of monolingual English models (i.e., models trained with English captions only). Although most CLIP models are trained on English-only imagecaption data, some effort has been put into creating multilingual and monolingual non-English models by (1) training them from scratch (Bianchi et al., 2021; Ilharco et al., 2021; Yang et al., 2022; Jain et al., 2021; Zhai et al., 2023) or (2) distilling them from English models (Carlsson et al., 2022; Chen et al., 2022b; Zhang et al., 2022; Visheratin, 2023), typically using parallel data as supervision. Despite attempts to translate ImageNet labels to other languages (Bianchi et al., 2021; Yang et al., 2022), the language coverage remains very limited. Because of this, multilingual CLIP models have mainly been benchmarked on image-text retrieval datasets (Aggarwal and Kale, 2020; Bugliarello et al., 2022; Thapliyal et al., 2022), which cover only limited sets of mid-to-high resource languages.
Creating massively multilingual datasets for VL tasks (e.g., image-text retrieval) is prohibitively expensive. Existing efforts (Aggarwal and Kale, 2020; Bugliarello et al., 2022; Thapliyal et al., 2022) either hire native speakers to write image captions in target languages or resort to machine translation (MT) of English data, followed by manual post-editing by native speakers. The MT approach
5064
(the cheaper of the two), is, we argue, still too expensive for low-resource languages because MT models are less accurate when translating to those languages, which implies a bigger post-editing effort for bilingual annotators, native in the lowresource language and fluent in English; in addition, such annotators are more difficult to find for lowresource than for high-resource target languages. In this work, we thus seek to create a robust massively multilingual benchmark for evaluating the quality of representation spaces of multilingual VL models, without resorting to MT or requiring any manual annotation effort. To be useful, such a benchmark needs to satisfy a crucial requirement: models’ performance across languages must be indicative of their performance for the same languages in tasks such as image-text retrieval, for which creating massively multilingual (gold-standard) evaluation datasets is too expensive. Contributions. With this in mind, we create BabelImageNet, a massively multilingual dataset for zero-shot image classification that offers (partial) translations of the 1000 ImageNet classes to 100 languages. To obtain robust translations of ImageNet labels in other languages, we leverage the connection between ImageNet classes, which are derived from WordNet (Miller, 1994) synsets, and BabelNet (Navigli and Ponzetto, 2010), a massively multilingual lexico-semantic network, also (in part) derived from WordNet. Relying on the multilingual BabelNet synsets (and WordNet synset identifiers of ImageNet classes) to pivot between languages, we avoid problems known to occur with machine translation of short phrases without context, e.g., due to polysemy1. Exploiting BabelNet allows us to automatically obtain labels for ImageNet concepts in many languages, removing the need for MT and manual annotation.
We evaluate 11 different multilingual CLIP models on Babel-ImageNet, observing that all of them exhibit poor performance for low-resource languages. Crucially, we validate that BabelImageNet is a meaningful benchmark for measuring the quality of multilingual VL representations by comparing models’ performance on BabelImageNet against their performance on established multilingual image-text retrieval datasets. BabelImageNet thus allows us to evaluate models in languages not covered by those datasets and it
1For example, the ImageNet class walking stick refers to the insect and not the inanimate object.
additionally expands the retrieval-focused evaluation with the ZS-IC task in languages included in the established datasets. Finally, we propose a computationally efficient approach for improving multilingual CLIP models for low-resource languages. This modular language specialization approach yields large performance gains (>20% for some of the low-resource languages).

heading: 2 Related Work
text: Multilingual Vision-and-Language Benchmarks. Early multilingual VL models (Gella et al., 2017; Wehrmann et al., 2019; Kim et al., 2020; Burns et al., 2020; Ni et al., 2021; Geigle et al., 2022; Zhou et al., 2021) were often evaluated in imagetext retrieval on Multi30k (Elliott et al., 2016, 2017; Barrault et al., 2018), an extension of Flickr30k (Plummer et al., 2015) to German, French, and Czech, as well as on the Japanese (Yoshikawa et al., 2017) and Chinese (Li et al., 2019) translations of MSCOCO (Lin et al., 2014). More recent models were evaluated on multilingual image-text retrieval benchmarks: XTD (Aggarwal and Kale, 2020) (10 languages) and WIT (Srinivasan et al., 2021) (108 languages). Both these benchmarks, however, have prominent shortcomings. XTD predominantly contains examples from Karpathy’s training portion of MSCOCO (Karpathy and FeiFei, 2017), which is commonly used for pretraining of VL models, which constitutes a case of data leakage (Bugliarello et al., 2022). WIT collects image-caption pairs from Wikipedia(s), which are abundant with named entity mentions that are often identical across a number languages – this artificially equates the difficulty of retrieval across languages (Zhai et al., 2022). More recently, IGLUE (Bugliarello et al., 2022) was introduced as the first benchmark to also include reasoning tasks like visual QA (Pfeiffer et al., 2022), primarily meant to test cross-encoder models that jointly encode image-text pairs (Ni et al., 2021; Zhou et al., 2021; Zeng et al., 2022). IGLUE also introduces the image-caption dataset xFlickrCo, a combination of Flickr30k and MSCOCO with new captions in 7 languages. Another recent dataset, XM3600 (Thapliyal et al., 2022), encompasses 3600 images (balanced by geography of origin) with captions in 36 languages written from scratch by native speakers.
Motivated by monolingual CLIP models in other languages, translations of ImageNet classes have emerged for a handful of high-resource languages:
Italian (obtained with MT) (Bianchi et al., 2021), Chinese (human translations) (Yang et al., 2022), and Japanese2 and Arabic3 (undisclosed methods). Extending ImageNet to more languages, however, is not feasible at scale, due to the challenges of finding native speakers to translate or verify machinetranslated labels. With Babel-ImageNet, we exploit the linkage between ImageNet and BabelNet through WordNet, to create the first robust massively multilingual translation of ImageNet classes, avoiding the caveats of polysemy associated with automatic translation of concepts.
Multilingual CLIP. CLIP (Radford et al., 2021) is not the first model to embed images and text in a shared representation space, but it has arguably become the most widely used one, owing its effectiveness – especially in ZS-IC – to the immense pretraining corpus. Older models, not exposed to large-scale VL pretraining, e.g., (Faghri et al., 2018) for English and (Gella et al., 2017; Wehrmann et al., 2019; Kim et al., 2020; Burns et al., 2020) multilingually, focused predominantly on text-to-image retrieval and were not shown to exhibit ZS-IC abilities. MURAL (Jain et al., 2021) was the first – albeit not publicly released – multilingual CLIP model, trained on billions of multilingual image-caption pairs. The only publicly available multilingual CLIP models trained “from scratch” are the OpenCLIP models (Ilharco et al., 2021) (trained on the full multilingual LAION5B dataset (Schuhmann et al., 2022)) and mSigLIP (Zhai et al., 2023) (trained on Google’s WebLI (Chen et al., 2022a)). Monolingual CLIP models for a few languages other than English (e.g., Italian, Chinese) have also been released (Bianchi et al.,
2github.com/rinnakk/japanese-clip 3github.com/LAION-AI/CLIP_benchmark/pull/68
2021; Yang et al., 2022): due to comparatively small pretraining data, they trail the English models. Given the huge computational cost of training a multilingual CLIP from scratch, teacher distillation (Reimers and Gurevych, 2020) has become popular as an efficient alternative (Carlsson et al., 2022; Chen et al., 2022b; Zhang et al., 2022): a multilingual text encoder (e.g., XLM-R (Conneau et al., 2020)) is forced (commonly using parallel sentences) to align its representation space to the text encoder of English CLIP.

heading: 3 Babel-ImageNet
text: Why (massively) multilingual ZS-IC? With class labels in a particular language we can evaluate VL models in language-specific ZS-IC. Note that the goal is not to improve the classification performance – using labels in any other language yields worse performance compared to using English labels. Instead, we argue that a model’s languagespecific ZS-IC performance is a good estimate of the quality of its multilingual VL representation space for the language, and thus a good predictor of the model’s performance for that language.
In addition, prior work evaluated models mainly with retrieval. For the languages, where such data exists, we provide a more comprehensive evaluation: ImageNet covers a far more diverse set of concepts than image captions usually contain.
WordNet as a matchmaker for ImageNet and BabelNet. Unlike in most image classification datasets (e.g., CIFAR10, Oxford Pets (Parkhi et al., 2012), Flowers102 (Nilsback and Zisserman, 2008)), where image classes are words, ImageNet (Deng et al., 2009) links images to concepts, represented with sets of synonyms (synsets) from English WordNet (Miller, 1994). BabelNet (Navigli
and Ponzetto, 2010) is a massively multilingual lexico-semantic network, automatically created by merging and consolidating numerous lexicosemantic resources: from WordNets in dozens of languages (e.g., (Hamp and Feldweg, 1997; Pianta et al., 2002)) to (massively multilingual) Wikipedia and WikiData (Vrandečić, 2012).4 Crucially for our efforts, BabelNet is (1) also organized in (multilingual) synsets, containing synonyms across many languages and (2) each of its synsets has an explicit link to the corresponding (English) WordNet synset (if such exists). With WordNet as the seam between ImageNet and BabelNet, we are able to create a massively multilingual ZS-IC benchmark, without resorting to manual annotation or MT.
Class Translation and Cleaning Process. We illustrate the general process in Figure 1. For every ImageNet class, using its WordNet synset ID, we fetch all synonyms in every language including English (where available). Next, we remove words that match an English word (of the same class) because models use their high-quality English representations for these words, distorting results and leading to misleadingly optimistic estimates of models’ multilingual abilities. Next, we eliminate all words that were added to BabelNet via machine translation, removing the potential negative effects of context-agnostic MT from our benchmark. Finally, we select for every class in every language the first remaining word (according to the order in BabelNet) as our final language-specific class label. Classes with no word are removed.
Language Selection. We find that of the 520 languages in BabelNet v5.2, 298 have at least 10 classes using our process, the majority of them being low- and very-low resource languages. We limit our evaluation to 100 non-English languages for more balanced selection of low-, mid- and highresource languages. To this end, we combine the 92 languages (counting unique ISO codes) covered by the pretraining corpora of XLM-R (Conneau et al., 2020) with 8 manually selected languages not covered by machine translation (neither Google, Microsoft, nor by NLLB (Costa-jussà et al., 2022)).
Grouping Languages in Evaluation. Comparing models’ performance over 100 languages (+English) is still unwieldy but averaging performance across all languages is too reductive and consequently not particularly informative. We thus opt
4BabelNet v5.2 consolidates 53 sources

heading: Source Objective #Data #Langs
text: for the middle ground: we group Babel-ImageNet languages in four buckets based on their number of classes (<101, 101 to 333, 334 to 667, and 668 to 1000). We argue that the number of classes is a reasonable proxy for general “resourceness” of a language (see §B.1 for the full list of languages and corresponding numbers of classes) and accordingly designate the four groups as very-low-, low-, mid-, and high-resource, encompassing 17, 32, 35, and 16 languages, respectively. Additionally, given that ZS-IC becomes easier with fewer classes, averaging results across languages with more comparable numbers of classes makes more sense than averaging them across all languages.
Verification. BabelNet mappings are automatically created and not error-free even though, for example, over 90% of Wikipedia-WordNet mappings were manually validated with a precision over 99.5% (Navigli et al., 2021). Still, we also manually verify our mappings on 4 languages with native speakers5 and on the 3 smallest languages (xh, om, ha) with online dictionaries; we find on average 5.4% errors. We believe this to be a very acceptable error rate, considering (i) that around 6% of ImageNet images are mislabeled (Northcutt et al., 2021) and (ii) that there are also erroneous mappings between ImageNet images and WordNet synsets (Nielsen, 2018; Radford et al., 2021).

heading: 4 Benchmarking CLIP Models
text: Models. We present the CLIP variants we benchmark on Babel-ImageNet (overview in Table 1). All use Vision Transformers (ViT) (Dosovitskiy et al., 2021) albeit of different sizes and with dif-
5The authors and colleagues. Languages: de, ur, tr, hr
ferently sized input patches (e.g., B-32 = Base Transformer with 32×32-pixel patches). OpenAI: The original CLIP (Radford et al., 2021), trained fully from scratch on 400M English image-caption pairs. OpenCLIP: OpenCLIP (Ilharco et al., 2021) aims to replicate the OpenAI models using the public LAION datasets (Schuhmann et al., 2021, 2022). Two multilingual models have been trained: the B32 model with the text encoder initialized with the weights of XLM-R-Base and the H-14 model initialized with XLM-R-Large. The B-32 variant is trained with the original contrastive CLIP objective, whereas the H-14 model was trained via locked image tuning (LiT, (Zhai et al., 2022)) in which the pretrained image encoder of the English H-14 OpenCLIP model is frozen and only the parameters of the text encoder are updated. SentenceTransformer(ST): One of the first distillation-based multilingual CLIP-like models using the approach of Reimers and Gurevych (2020),6 with over 50M EN-X parallel sentences (X being one of 49 other languages) as supervision. They distill a (distilled) mBERT student (Devlin et al., 2019) from the English OpenAI B-32 teacher. M-CLIP: Multilingual-CLIP (M-CLIP) (Carlsson et al., 2022) is a model distilled using mBERT and OpenAI B-32 with translations of 3M English image captions to 69 languages as parallel supervision. Post-publication, they released a set of models7 with XLM-R-Large as the student and OpenAI B-32, L-14, and OpenCLIP B-16+ as teachers. These models were trained on 7M captions by Li et al. (2022), translated to 48 languages.
6CLIP-VIT-B-32-MULTILINGUAL-V1 7github.com/FreddeFrallan/Multilingual-CLIP
AltCLIP: This model by Chen et al. (2022b) distills an XLM-R-Large student with OpenAI L14 as teacher, targeting 9 languages and using as training data a mix of machine-translated captions, multilingual captions sampled from LAION5B, and aligned English-X sentence pairs. After distillation, the authors additionally fine-tune the model via LiT using selected image-text pairs from LAION5B in the 9 target languages. SigLIP: The multilingual mSigLIP (Zhai et al., 2023) is a B-16-size CLIP model trained from scratch on Google’s multilingual WebLI dataset (Chen et al., 2022a). They replace the softmax function used in the original CLIP with a sigmoid for more compute-efficient training. NLLB-SigLIP: The NLLB-CLIP models (Visheratin, 2023) are a suite of CLIP models trained with LiT using 100k image-caption pairs translated fully for all 200 languages supported by NLLB (Costa-jussà et al., 2022) for 20M examples in total. They use SigLIP B-16 and SO400M-14 as image encoders with the encoders of NLLB-600Mdistilled and NLLB-1.3B-distilled as text encoders, which we call base and large, respectively.
Zero-Shot Image Classification Setup. We adopt the ZS-IC setup of Radford et al. (2021): for an image-label pair, the image embedding is obtained directly from the image encoder; the label is inserted into 80 different prompt templates (from (Radford et al., 2021)), each of which is independently embedded by the text encoder – the final label representation is then the mean of prompt embeddings. The class with the label embedding that is most similar to the image embedding (according to cosine similarity) is taken as the prediction; accuracy (top-1) is the evaluation metric.
Translating Prompts. We translate the 80 English prompts used by Radford et al. (2021) to our 100 languages using NLLB (Costa-jussà et al., 2022) (nllb-200-distilled-1.3B; see §B.2 for details). We show (see §C.1) that translated, language-specific prompts lead to better performance compared to using only the class labels or inserting them into the original English prompts. Moreover (see §C.2), we show that translated prompts yield similar performance as humancrafted prompts in ar, it, ja, and zh.
ZS-IC Results. Table 2 summarizes the results for the four language groups, alongside the English performance. The full results for all 100 languages can be found in the Appendix (Table 8).
These results make it abundantly clear that multilingual CLIP models perform dramatically worse (i) for high-resource languages than for English, and (ii) for low- and mid-resource languages than for high-resource languages. Note that this is despite the classification tasks a priori being easiest for low-resource languages (under 333 classes) and hardest for English, where models must distinguish between all 1000 classes of ImageNet.
The English ImageNet performance of the models is not indicative of their ZS-IC performance for other languages, especially low-resource ones: for example, OpenCLIP XLMR-L H-14 outperforms M-CLIP XLMR-L L-14 by 25 accuracy points on English ImageNet, yet trails it 8.6 points on average for low-resource languages. We believe that this points to the “curse of multilinguality” of the text encoder – namely that, under a fixed model capacity, an improvement of representation quality for some language(s) comes at the expense of representational deterioration for others. This phenomenon has been well-documented in particular for XLM-R (Conneau et al., 2020; Pfeiffer et al., 2020b). Among the model variants obtained with the same training procedure (e.g., four variants of M-CLIP), English performance does seem to correlate with the performance on other languages.
The OpenCLIP models and mSigLIP, both trained on massive web-crawled corpora, yield good results for high- and mid-resource languages but perform poorly (in comparison to M-CLIP and NLLB-SigLIP) for low-resource languages. In §C.4, we demonstrate that OpenCLIP performance strongly correlates with the distribution of languages in LAION5B: this would suggest that contrastive training (i.e., CLIP and LiT) leads to
poor cross-language generalization. In contrast, the better performance of (XLMR-based) M-CLIP models on low-resource languages suggests that distillation-based training offers stronger cross-lingual generalization (and yields best performance even for languages unseen in distillation training, see §C.3). We hypothesize that by aligning representations of captions in all other languages to the representations of corresponding English captions results in a more language-agnostic representation space. At the same time, in line with the “curse of multilinguality”, this improved generalization is paid with reduced quality of representations of high-resource languages, where M-CLIP models fall well behind.
The NLLB-SigLIP models, which combine a strong image encoder with the NLLB encoders trained on 200 languages, show impressive results for low- to mid-resource languages but underperform for the high-resource languages, suggesting again a trade-off between languages.
The trade-off between cross-lingual generalization and per-language performance is best exemplified with AltCLIP: the model is exceptionally good for the 9 languages present in its large-scale distillation training (§C.3), yet performs (comparatively) poorly for most other languages – training on a very large dataset for only a few languages simply overwrites the XLM-R’s knowledge of other languages, obtained in its original pretraining.
The two mBERT-based models significantly underperform all other models. This is in part due to mBERT being generally a weaker multilingual text encoder (Hu et al., 2020; Lauscher et al., 2020). On top of that, M-CLIP mBERT variants have been trained on less data than XLM-R-based counterparts (3M vs. 7M captions) and ST is distilled with parallel sentences that are not image captions.

heading: 5 Validating Babel-ImageNet
text: We perform two additional analyses that establish the validity of Babel-ImageNet as a benchmark: (1) how different number of classes affects performance and findings across languages and (2) how ZS-IC performance on Babel-ImageNet relates to multilingual image-text retrieval performance. We provide further analyses in the Appendix.
Effect of number of classes on ZS-IC accuracy. Babel-ImageNet is an incomplete translation of the ImageNet classes (see §3). Intuitively, classification with fewer classes is easier and results in

heading: 200 400 600 800 1000
text: higher absolute performance for all models. Our analysis of how the number of classes affects the ZS-IC performance on the English ImageNet for OpenAI CLIP models (B-32 and L-14) confirms this. Figure 2 shows that the task difficulty (i.e., ZS-IC performance) is log-linear in the number of classes: this makes intuitive sense – moving from 50 to 100 classes increases the difficulty more than going from 900 to 950 classes.
We next fix the number of classes to 100 for all Babel-ImageNet languages (except for languages with <100 classes, for which we make no changes) and report the performance in Table 3 (for each language, we average the results over 10 different randomly selected subsets of 100 classes). While in absolute terms the ZS-IC performance increases compared to full class sets (Table 2), and gaps between the language groups widen , our observations do not change: NLLB-SigLIP still exhibits the best performance for low-resource languages, whereas OpenCLIP and mSigLIP are still best for high-resource languages. This renders the (full) Babel-ImageNet a reliable benchmark for directly comparing multilingual VL models.
Multilingual ZS-IC & multilingual image-text retrieval. The existing body of work commonly evaluates multilingual VL models in image-text retrieval. One goal of Babel-ImageNet, which measures multilingual ZS-IC performance, is to reflect (or, at least, give an estimate of) the quality of the multilingual embedding spaces of VL model. We thus compare how models’ performance on Babel-ImageNet correlates with their performance on three different multilingual image-text retrieval datasets: xFlickrCo (Bugliarello et al., 2022), XTD (Aggarwal and Kale, 2020), and XM3600 (Thapliyal et al., 2022), covering 7, 10, and 348 languages. We use R@1 in text-to-image retrieval as the evaluation metric: it captures the percentage of examples where a correct image is top-ranked for a given caption. We report the full retrieval results in the Appendix (Tables 10, 11, and 12).
Figure 3 displays the retrieval results on xFlickrCo, XM3600, and XTD, respectively, against the ZS-IC accuracy on Babel-ImageNet: each dot represents one model-language combination. The plots reveal high correlation between the BabelImageNet and text-to-image retrieval scores across model-language pairs: 0.67 for xFlickrCo, 0.75 for XM3600, and 0.66 for XTD. It is particularly positive that Babel-ImageNet shows the highest correlation with XM3600, with which it intersects in most languages (34). These results confirm that Babel-ImageNet is a sensible benchmark for comparing proficiency of VL models for a multitude of languages not covered by existing benchmarks.
The evaluation also reveals model-specific idiosyncrasies that consideration of either task alone would not have shown. For example, models that use a higher image resolution (M-CLIP B-16+, NLLB-SigLIPs) perform relatively better for retrieval, where the increased detail helps, than for ZS-IC. mSigLIP, potentially due to its small text encoder (compared to, e.g., XLM-R-large), is not as strong for retrieval as in ZS-IC. With the addition of ZS-IC to formerly retrieval-only multilingual evaluation, Babel-ImageNet allows for a more comprehensive evaluation of models.

heading: 6 Improving Multilingual CLIP for Low-Resource Languages
text: Finally, we improve the performance for lowresource languages by resorting to parameter-
8For correlation analysis, we exclude mi and quz as they are not under the 100 Babel-ImageNet languages.

heading: Model Loss xh si lo ur my hi ms et sk lt eu ar ko fa de zh
text: efficient fine-tuning with adapters (Houlsby et al., 2019; Pfeiffer et al., 2020b), trainable bottleneck layers that we insert into the text encoder. We only update adapter parameters, keeping the original CLIP parameters frozen. We train a separate adapter for each language.
Setup. We train language-specific adapters on top of (a) OpenClip B-32 model (trained from scratch) and (b) M-CLIP XLMR-L B-32 (obtained via distillation). We experiment with three training objectives: English-target language distillation with (i) MSE and (ii) contrastive loss, and (iii) LiT on image-caption pairs. The former two require parallel data, whereas the latter requires images paired with target-language captions. For comparability between languages, we sample 100K captions (with corresponding images) from the synthetic dataset provided by Li et al. (2022) and translate them automatically to all target languages with NLLB. We perform adapter-based specialization for 16 languages. One run (i.e., one modellanguage-objective combination) takes 3h on a sin-
gle Nvidia RTX 3090 card (see §B.3 for details).
Results. Table 4 displays the results. For lowresource languages (xh, si, lo, my, and eu), we observe massive improvements. In contrast, the adaptation brings performance losses for high-resource languages (e.g., de and zh). We hypothesize that constraining the representation space of a target language to English representations is beneficial for low-resource languages with semantically poor initial representations, but detrimental for highresource languages with semantically accurate initial representations. For both OpenCLIP and MCLIP, adaptation with the MSE objective on parallel sentences yields the best results. Overall, the trends in performance changes from language adaptation are very similar between OpenCLIP and MCLIP, despite the fact that they were obtained using very different training procedures and trained on datasets with different language distributions. This suggests that this commonality in language adaptation behavior stems from the initialization of the text encoder with XLM-R weights.

heading: 7 Conclusion
text: We introduced Babel-ImageNet, the first massively multilingual translation of the ImageNet classes to 100 languages. We leverage the WordNet synsets as the link between ImageNet and BabelNet to obtain high-quality translations without relying on MT or human annotators. Using Babel-ImageNet, we carried out the most comprehensively multilingual comparative evaluation of 11 public CLIP models on zero-shot image classification, demonstrating that all models fail for low(er)-resource languages. Crucially, we validate our benchmark by showing that models’ text-to-image retrieval performance (on three datasets) strongly correlates with their ZS-IC performance on Babel-ImageNet for the corresponding languages. Finally, we proposed a parameter-efficient fine-tuning procedure that drastically improves the performance of multilingual CLIP models for low-resource languages.
The wide range of languages encompassed by our benchmark reveals that the theoretical “multilinguality” of CLIP models is practically very limited and points to the need for methods that derive robust VL encoders with much stronger performance especially for low-resource languages: e.g., better distillation procedures that retain more of the impressive performance of English CLIP.

heading: 8 Limitations
text: While Babel-ImageNet greatly improves language coverage for evaluation of multilingual VL models, there are some limitations of our work:
For one, ImageNet classes tend to be Anglocentric due to inherited biases from WordNet (Shankar et al., 2017; DeVries et al., 2019; Liu et al., 2021) so while our benchmark evaluates the performance on languages from all over the globe, we do not evaluate the model performance on concepts specific (or even unique) to cultures in which those languages are spoken. As a result, BabelImageNet may overestimate the actual usability of an VL model for real-world uses in some cultures and geographies.
Further, we select for Babel-ImageNet the 92 languages used in XLM-R pretraining along with 8 more manually chosen languages. This selection reinforces research focus on those languages to the detriment of other (mainly extremely low-resource) languages. However, we release our code, as well as data for labels of 298 languages and encourage future research to consider an even wider set of
languages.

heading: Acknowledgements
text: This work was in part supported by the Alexander von Humboldt Foundation.

heading: A License
text: Babel-ImageNet is a processed version of BabelNet v5.2 downloaded from https://babelnet. org, made available with the BabelNet NonCommercial License (see https://babelnet. org/full-license).

heading: B Data and Training Details

heading: B.1 Babel-ImageNet
text: Table 5 lists the 100 Babel-ImageNet languages with their corresponding number of classes.
Figure 4 visualizes the relationship between the number of classes of a language in Babel-ImageNet and the number of tokens for the language in the XLM-R pretraining corpus (which we use as a proxy for the language “resourceness”). We see that the two are generally correlated (Spearman rank correlation of 0.78), albeit with some expected outliers, e.g., Chinese is ”token-compact“ so the token count does not reflect its high-resourceness well.

heading: B.2 Prompts
text: We use NLLB (Costa-jussà et al., 2022) (nllb-200distilled-1.3B) to translate the 80 prompts used by Radford et al. (2021) to our 100 languages. The exceptions are fy, la, br, wuu, nv, cv, diq, chr, ce, hak, nah, which are not supported by NLLB; for those languages we report the better results between: (1) using only the language-specific labels and (2) inserting ‘labels’ into English prompts. For the ISO 639-1 languages corresponding to macro languages, there is only one corresponding ISO 639-3 language in NLLB, except for no where we choose Bokmål and for az where we choose North Azerbaijani. We translate the prompts in their template form with the {} placeholders. We use a range of different methods like HTML tags or other special characters to increase the likelihood of preserving the placeholders during translation and then select the first successful approach. If no method worked, we append {} to the end of the sentence. We perform no language-specific adaptions like combining prompt variants with definite and indefinite articles for languages where this distinction does not exist (or articles do not exist at all) nor do we account for the grammatical gender of the classes when inserting them in the template.

heading: B.3 Training
text: Training Data: For the language-specific adaptation training in §6, we leveraged the BLIP (Li et al., 2022) image-caption dataset CCS_SYNTHETIC_FILTERED_LARGE.JSON9.
Hyperparameters: We train with AdamW (Loshchilov and Hutter, 2019), 0.1 weight decay, a linear learning rate schedule with 20% warmup, learning rate 1e-3 (chosen with sweep over 1e3, 5e-4, 3e-4, 1e-4), batch size 512 (OpenCLIP)/ 192 (M-CLIP), for 100 epochs (OpenCLIP)/ 15 epochs (M-CLIP; longer training yielded no improvements). Hyperparameters are chosen based on results on Sinhala. We perform no early stopping and use the last epoch for evaluation. The temperature for the contrastive loss is a trainable parameter as in Radford et al. (2021) but we freeze it for text contrastive loss (training it resulted in worse results). The maximum text sequence length is 70. For adapters, we use the Pfeiffer architecture (Pfeiffer et al., 2020b) (task adapters, not language adapters) with reduction factor 16 with the implementation from AdapterHub (Pfeiffer et al., 2020a). We pre-encode images and English captions; i.e. the English embeddings for MSE and contrastive loss are not computed by the trained model but come from the model before training. We do not use any type of image augmentation.
Negative results: We experimented with the following methods but did not pursue them further due to not-better or poor results.
1. Training with MSE loss using aligned EnglishX sentences from WikiMatrix (Schwenk et al., 2021), similar to the ST and (in part) AltCLIP models, resulted in a performance decrease throughout (except for si with OpenCLIP) as Table 6 shows. This suggests that it is important to use “visually-descriptive” parallel data (i.e., parallel image captions), rather than any parallel data.
2. LoRA fine-tuning (Hu et al., 2022) (α = 8, r = 16, lr 1e-3 after sweep) significantly (>10% on si) underperformed adapter-based fine-tuning.
3. SimCSE loss (a self-supervised objective) (Gao et al., 2021) based only on targetlanguage captions yielded no improvements
9https://github.com/salesforce/BLIP# pre-training-datasets-download
compare to the initial model, i.e., without any additional language-specialization training (experimented with OpenCLIP and batch size 256).
4. Multitask training with both LiT and MSE distillation objectives produced no gains compared to training only with the MSE objective.

heading: C Further Experiments and Analysis

heading: C.1 Experimental Validation of Machine-translated Prompts
text: We show in Figure 5 that our translated prompts produce better results (on average, across all languages), compared to (i) using just the labels and (ii) inserting the translated labels into the original English prompts created by Radford et al. (2021). With the translated prompts, we get gains of over 2 points for low-resource languages and up to 5 points for high-resource languages.

heading: C.2 Comparison with Existing ImageNet Translations
text: Prior work has created full translations of the 1k ImageNet classes into ar, zh, jp, it along with humanwritten prompts for those languages. We use those translations to validate our BabelNet-derived labels and MT prompts: We evaluate models on the subset of ImageNet classes available for each language in Babel-ImageNet and compare a) only labels and b) human-created templates vs. our MT prompts. Results are shown in Figure 6. While results for ar and it are slighly higher in absolute numbers on the existing translation, the relative order of models on the Babel-ImageNet benchmarks of those languages is nearly identical to their relative ranking on the respective benchmarks with manually translated ImageNet labels.
We observe that the human-written prompts do not result in a relative improvement over our MT prompts (i.e. no down-shift parallel to the x = y line). In fact, for it, our MT prompts even close the gap slightly compared to the label-only setup.

heading: C.3 Performance Differences between Distilled and Not-Distilled Languages
text: With teacher distillation, one would expect the performance in the languages seen in the distillation data to be better than in other languages, not used for distillation. With the wide language selection of our benchmark, we can analyze in-depth how performance on “distilled” languages differs from the performance on “non-distilled” languages.
We compare results for distilled languages on the low/mid/high-resource language groups for MCLIP and AltCLIP in Table 7; we use the OpenCLIP H-14 model as reference for an expected ‘baseline’ ∆-difference in performance between the distilled/not-distilled language groups that is due to other factors inherent to the specific languages and not the distillation. For AltCLIP, we see that the the performance on the 8 distilled languages is significantly better than on the non-distilled languages. Moreover, the performance on its distilled languages is even comparable to that of the larger H-14 model. For M-CLIP, the performance on the distilled languages is only slightly better than on the non-distilled low- and mid-resource languages when compared to the OpenCLIP model and the gap is even smaller for high-resource languages. Interestingly, the performance on non-distilled lowresource languages is still noticeably better for MCLIP than for the OpenCLIP H-14 model. We speculate that the shorter training of M-CLIP compared to OpenCLIP might retain more of the languagespecific competences for low-resource languages, obtained in XLM-R pretraining.

heading: C.4 LAION5B: Language Distribution and Performance
text: The distillation-based models evaluated in our benchmark use the same number of training examples for every language. The OpenCLIP models, on the other hand, are trained on LAION5B which follows a more ‘natural’ distribution of image-caption pairs across languages, as found on the web: Figure 7b shows that over half the data is English, 7 highresource languages account for another 25% of the data, whereas all remaining languages “share” the remaining 25%.
We can see in Figure 7a that the OpenCLIP’s ZS-IC performance for Babel-ImageNet languages highly depends on the number of instances of those languages in the LAION5B dataset. The Spearman rank correlation between the number of languagespecific LAION5B examples and the respective Babel-ImageNet accuracy for the language is 0.76. This suggests that pure image-text contrastive pretraining results in poor generalization and limited
cross-lingual gains to languages unseen in pretraining. Additional training objectives that aim to better align the multilingual space for example using paired text like in MURAL (Jain et al., 2021) might be necessary to improve results of OpenCLIP-like models (trained from scratch) for low-resource languages.

heading: Model Loss xh si lo ur my hi ms et sk lt eu ar ko fa de zh
text: 105 107 109 LAION5B Examples (log10)
0.0
0.2
0.4
0.6
0.8
Ba be
l-I m
ag eN
et a
cc ur
ac y
model = OpenCLIP XLMR B-32
105 107 109 LAION5B Examples (log10)
model = OpenCLIP XLMR-L H-14
(a) Accuracy of the LAION5B-trained OpenCLIP models for the 92 Babel-ImageNet languages plotted against the number of examples for each language in LAION5B (log10).
EN 52%
RU
5%
FR
4%
DE
3% ES
3% ZH
3% JA 3%
IT2% PT 2%
NL 1%
PL
1%
NO
1%
VI
1%
TR
1%
LA
1
GL
1%
DA
1
CS
1%
BG
1
SV
%
CA
1
EL
%
AF
1
FY
1%
ID
1
HU
%
AR
1
UK
0%
FASR
0%
CYJV
0
HI
%
RO
0
SKMS
0%
FIKO
0
ETMG
%
SL
0
GDLTSU
0%
EOBEGA
0
THHA
%
KYEU
0
BXHAZSOU
0%
HRQLVMK
0
URNIS
%
MNSWURDPBN
0
HYTAKYIGELALOASBRHEOMSATLUG
(b) Distribution of languages in LAION5B (exluding the 1.3B no-language examples) shows that most examples are either English or one of a few other languages.
Figure 7: The relationship between the LAION5B language distribution with the performance of OpenCLIP models trained on that data.

heading: D Full Results
text: We report full results for all languages on (i) BabelImageNet and (ii) each of the three image-text retrieval datasets: xFlickrCo, XM3600, and XTD.

heading: Future Work
text: However, we release our code, as well as data for labels of 298 languages and encourage future research to consider an even wider set of
languages