import csv import random from itertools import combinations from pathlib import Path from typing import Any, Dict, List, Union import datasets import numpy as np import pandas as pd # fmt: off LANGS = [ "ace_Arab", "ace_Latn", "acm_Arab", "acq_Arab", "aeb_Arab", "afr_Latn", "ajp_Arab", "aka_Latn", "als_Latn", "amh_Ethi", "apc_Arab", "arb_Arab", "arb_Latn", "ars_Arab", "ary_Arab", "arz_Arab", "asm_Beng", "ast_Latn", "awa_Deva", "ayr_Latn", "azb_Arab", "azj_Latn", "bak_Cyrl", "bam_Latn", "ban_Latn", "bel_Cyrl", "bem_Latn", "ben_Beng", "bho_Deva", "bjn_Arab", "bjn_Latn", "bod_Tibt", "bos_Latn", "bug_Latn", "bul_Cyrl", "cat_Latn", "ceb_Latn", "ces_Latn", "cjk_Latn", "ckb_Arab", "crh_Latn", "cym_Latn", "dan_Latn", "deu_Latn", "dik_Latn", "dyu_Latn", "dzo_Tibt", "ell_Grek", "eng_Latn", "epo_Latn", "est_Latn", "eus_Latn", "ewe_Latn", "fao_Latn", "fij_Latn", "fin_Latn", "fon_Latn", "fra_Latn", "fur_Latn", "fuv_Latn", "gaz_Latn", "gla_Latn", "gle_Latn", "glg_Latn", "grn_Latn", "guj_Gujr", "hat_Latn", "hau_Latn", "heb_Hebr", "hin_Deva", "hne_Deva", "hrv_Latn", "hun_Latn", "hye_Armn", "ibo_Latn", "ilo_Latn", "ind_Latn", "isl_Latn", "ita_Latn", "jav_Latn", "jpn_Jpan", "kab_Latn", "kac_Latn", "kam_Latn", "kan_Knda", "kas_Arab", "kas_Deva", "kat_Geor", "kaz_Cyrl", "kbp_Latn", "kea_Latn", "khk_Cyrl", "khm_Khmr", "kik_Latn", "kin_Latn", "kir_Cyrl", "kmb_Latn", "kmr_Latn", "knc_Arab", "knc_Latn", "kon_Latn", "kor_Hang", "lao_Laoo", "lij_Latn", "lim_Latn", "lin_Latn", "lit_Latn", "lmo_Latn", "ltg_Latn", "ltz_Latn", "lua_Latn", "lug_Latn", "luo_Latn", "lus_Latn", "lvs_Latn", "mag_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "min_Arab", "min_Latn", "mkd_Cyrl", "mlt_Latn", "mni_Beng", "mos_Latn", "mri_Latn", "mya_Mymr", "nld_Latn", "nno_Latn", "nob_Latn", "npi_Deva", "nqo_Nkoo", "nso_Latn", "nus_Latn", "nya_Latn", "oci_Latn", "ory_Orya", "pag_Latn", "pan_Guru", "pap_Latn", "pbt_Arab", "pes_Arab", "plt_Latn", "pol_Latn", "por_Latn", "prs_Arab", "quy_Latn", "ron_Latn", "run_Latn", "rus_Cyrl", "sag_Latn", "san_Deva", "sat_Olck", "scn_Latn", "shn_Mymr", "sin_Sinh", "slk_Latn", "slv_Latn", "smo_Latn", "sna_Latn", "snd_Arab", "som_Latn", "sot_Latn", "spa_Latn", "srd_Latn", "srp_Cyrl", "ssw_Latn", "sun_Latn", "swe_Latn", "swh_Latn", "szl_Latn", "tam_Taml", "taq_Latn", "taq_Tfng", "tat_Cyrl", "tel_Telu", "tgk_Cyrl", "tgl_Latn", "tha_Thai", "tir_Ethi", "tpi_Latn", "tsn_Latn", "tso_Latn", "tuk_Latn", "tum_Latn", "tur_Latn", "twi_Latn", "tzm_Tfng", "uig_Arab", "ukr_Cyrl", "umb_Latn", "urd_Arab", "uzn_Latn", "vec_Latn", "vie_Latn", "war_Latn", "wol_Latn", "xho_Latn", "ydd_Hebr", "yor_Latn", "yue_Hant", "zho_Hans", "zho_Hant", "zsm_Latn", "zul_Latn" ] # fmt: on # For interactive usage: # Attempt to find the script directory if __file__ is defined, otherwise default to current working directory. try: cwd = Path(__file__).parent except NameError as _: cwd = Path.cwd() SEED: int = 42 N: int = 1004 # length of pooled train, dev, and test splits UPSAMPLING_FACTOR: int = 3 NUM_NEGATIVES: int = 3 NUM_REFERENCES: int = 5 NUM_EXAMPLES_PER_OPTION: int = 1 CATEGORIES: List[str] = [ "entertainment", "geography", "health", "politics", "science", "sports", "travel", ] # Prompts for classification tasks IMG2SENT_PROMPT: str = ( "Which option best matches the topic of the reference images? " 'The available topics are "entertainment", "geograpy", "health", ' '"politics", "science and technology", "sports", and "travel". ' "Choose one from A, B, C, D and only output a single letter." ) SENT2IMG_PROMPT: str = ( "Which option best matches the topic of the reference sentences? " 'The available topics are "entertainment", "geograpy", "health", ' '"politics", "science and technology", "sports", and "travel". ' "Choose one from A, B, C, D and only output a single letter." ) # URLs for downloading SIB .tsv data and images. _SIB_URL: str = "https://huggingface.co/datasets/fdschmidt93/mvlb/resolve/main/data/sib200/{lang}/{split}.tsv" _IMG_URL: str = "https://huggingface.co/datasets/fdschmidt93/mvlb/resolve/main/data/images/sib200/{category}_{no}.jpg" # Placeholder for dataset description: fill or extend as needed. _DESCRIPTION: str = ( "MVLSIB is a multilingual dataset designed to provide sentence-image pairs " "spanning multiple languages and categories. The goal is to support tasks such as " "multimodal classification, cross-lingual information retrieval, and more. " "Each row contains a textual entry (sentence) along with category information, " "and the dataset also includes image references for the same set of categories." ) def read_tsv_to_dict_list(file_path: Union[str, Path]) -> List[Dict[str, Any]]: """ Reads a TSV file with columns 'index_id', 'category', and 'text' into a list of dictionaries. The TSV is expected to have the following columns (in order): 1. index_id 2. category 3. text Parameters ---------- file_path : Union[str, Path] The path to the TSV file. Returns ------- List[Dict[str, Any]] A list of dictionaries, where each element has keys: - 'index_id': int - 'category': str - 'text': str Raises ------ ValueError If the TSV headers do not match the expected format. """ data: List[Dict[str, Any]] = [] expected_headers = ["index_id", "category", "text"] with open(file_path, mode="r", encoding="utf-8") as tsvfile: reader = csv.DictReader(tsvfile, delimiter="\t") # Validate headers if reader.fieldnames != expected_headers: raise ValueError( f"Expected headers {expected_headers}, but got {reader.fieldnames}" ) # Start enumerating from line 2 to account for the header line for _, row in enumerate(reader, start=2): # Convert index_id to integer index_id = int(row["index_id"]) # Strip leading/trailing whitespace category = row["category"].strip() text = row["text"].strip() # Append the processed row to data data.append({"index_id": index_id, "category": category, "text": text}) return data def read_lang_tsv(filepaths: List[str]) -> List[Dict[str, Any]]: """ Reads a list of TSV file paths containing SIB data in the same language and merges them into a single, sorted list of dictionaries. Specifically: 1. Calls `read_tsv_to_dict_list` for each file path. 2. Merges all resulting dictionaries. 3. Sorts by 'index_id'. Also normalizes the category "science/technology" to "science" for internal consistency. Parameters ---------- filepaths : List[str] A list of TSV file paths for a specific language. Returns ------- List[Dict[str, Any]] A list of dictionaries sorted by 'index_id' with normalized categories. """ # Read each file into a list of dicts dicos = [read_tsv_to_dict_list(path) for path in filepaths] # Flatten and sort by index_id out: List[Dict[str, Any]] = sorted( [line for dico in dicos for line in dico], key=lambda row: row["index_id"] ) # Normalize "science/technology" to "science" for line in out: if line["category"] == "science/technology": line["category"] = "science" return out def replicate_and_negatives( df: pd.DataFrame, num_replicates: int = 2, num_negatives: int = 2, num_positives: int = 2, seed: int = 42, ) -> pd.DataFrame: """ Create multiple replicated rows from the input DataFrame `df` and sample negative and positive examples for each row. Negative samples are drawn from rows whose category does NOT match the row's category. Positive samples are drawn from rows of the same category (excluding the row's own 'index_id'). Parameters ---------- df : pd.DataFrame The original input DataFrame with columns ['index_id', 'category', 'text']. num_replicates : int, optional Number of times to replicate each row, by default 2. num_negatives : int, optional Number of negative samples to pick for each row, by default 2. num_positives : int, optional Number of positive samples to pick for each row, by default 2. seed : int, optional Seed for random operations, by default 42. Returns ------- pd.DataFrame A new DataFrame containing replicated rows plus columns: - neg_id_i, neg_cat_i, neg_text_i for i in [0 .. num_neg-1] - pos_id_i, pos_cat_i, pos_text_i for i in [0 .. num_positives-1] Notes ----- - If the negative pool for a given category is smaller than `num_negatives`, sampling is done with replacement to ensure `num_negatives` items are drawn. - Similarly, positive sampling with replacement occurs if the pool (excluding the row itself) is smaller than `num_positives`. """ rng = np.random.default_rng(seed=seed) # 1) Replicate the DataFrame k (=num_replicates) times df_new = pd.concat([df] * num_replicates, ignore_index=True) # 2) Create empty columns for negative and positive samples for i in range(num_negatives): df_new[f"neg_id_{i}"] = None df_new[f"neg_cat_{i}"] = None df_new[f"neg_text_{i}"] = None for i in range(num_positives): df_new[f"pos_id_{i}"] = None df_new[f"pos_cat_{i}"] = None df_new[f"pos_text_{i}"] = None # 3) Build a negative pool by category (rows that are NOT in the given category) full_neg_pool = df.loc[:, ["index_id", "category", "text"]] # Dictionary: cat -> DataFrame of rows not in 'cat' full_neg_pool_by_cat = {} unique_cats = df["category"].unique() for cat in unique_cats: mask = full_neg_pool["category"] != cat full_neg_pool_by_cat[cat] = full_neg_pool[mask].reset_index(drop=True) # 4) Build a positive pool by category (rows in the same category) pos_pool_by_cat = {} for cat in unique_cats: mask = df["category"] == cat pos_pool_by_cat[cat] = df.loc[ mask, ["index_id", "category", "text"] ].reset_index(drop=True) # 5) Group df_new by category to handle negative/positive sampling per category grouped = df_new.groupby("category", group_keys=False) output_chunks: List[pd.DataFrame] = [] for cat, group_df in grouped: # ----- Negative Sampling ----- neg_pool_cat = full_neg_pool_by_cat[cat] neg_ids_arr = neg_pool_cat["index_id"].to_numpy() neg_cat_arr = neg_pool_cat["category"].to_numpy() neg_text_arr = neg_pool_cat["text"].to_numpy() neg_pool_size = len(neg_pool_cat) g_size = len(group_df) neg_id_cols = [np.empty(g_size, dtype=object) for _ in range(num_negatives)] neg_cat_cols = [np.empty(g_size, dtype=object) for _ in range(num_negatives)] neg_text_cols = [np.empty(g_size, dtype=object) for _ in range(num_negatives)] for r_i in range(g_size): # Decide if we have enough items to do no replacement replace_neg_for_row = neg_pool_size < num_negatives chosen_indices = rng.choice( np.arange(neg_pool_size), size=num_negatives, replace=replace_neg_for_row, ) for j in range(num_negatives): pick_idx = chosen_indices[j] neg_id_cols[j][r_i] = neg_ids_arr[pick_idx] neg_cat_cols[j][r_i] = neg_cat_arr[pick_idx] neg_text_cols[j][r_i] = neg_text_arr[pick_idx] for j in range(num_negatives): group_df[f"neg_id_{j}"] = neg_id_cols[j] group_df[f"neg_cat_{j}"] = neg_cat_cols[j] group_df[f"neg_text_{j}"] = neg_text_cols[j] # ----- Positive Sampling ----- pos_pool_cat = pos_pool_by_cat[cat] pos_ids_arr = pos_pool_cat["index_id"].to_numpy() pos_cat_arr = pos_pool_cat["category"].to_numpy() pos_text_arr = pos_pool_cat["text"].to_numpy() pos_id_cols = [np.empty(g_size, dtype=object) for _ in range(num_positives)] pos_cat_cols = [np.empty(g_size, dtype=object) for _ in range(num_positives)] pos_text_cols = [np.empty(g_size, dtype=object) for _ in range(num_positives)] row_ids_for_group = group_df["index_id"].to_numpy() for r_i in range(g_size): row_id = row_ids_for_group[r_i] # Exclude the row's own ID from sampling valid_mask = pos_ids_arr != row_id valid_idx_array = np.where(valid_mask)[0] replace_pos_for_row = len(valid_idx_array) < num_positives chosen_indices = rng.choice( valid_idx_array, size=num_positives, replace=replace_pos_for_row ) for j in range(num_positives): pick_idx = chosen_indices[j] pos_id_cols[j][r_i] = pos_ids_arr[pick_idx] pos_cat_cols[j][r_i] = pos_cat_arr[pick_idx] pos_text_cols[j][r_i] = pos_text_arr[pick_idx] for j in range(num_positives): group_df[f"pos_id_{j}"] = pos_id_cols[j] group_df[f"pos_cat_{j}"] = pos_cat_cols[j] group_df[f"pos_text_{j}"] = pos_text_cols[j] output_chunks.append(group_df) # 6) Combine modified chunks and restore original index order df_out = pd.concat(output_chunks, axis=0) df_out.sort_index(inplace=True) return df_out def get_reference_image_ids( N: int, num_images: int, k: int, seed: int ) -> List[List[int]]: """ Generates reference image ID combinations for each row in a dataset of size N. We pick (k)-combinations from the range [1 .. num_images-1]. Then we sample from these combinations (with replacement) for each of N rows, and shuffle them in a reproducible manner. Parameters ---------- N : int Number of rows in the dataset. num_images : int Total number of images available per category. k : int Number of images to select in each combination. seed : int Global seed for random operations. Returns ------- List[List[int]] A list of length N, where each element is a list of k unique image IDs. Notes ----- - We use Python's `random.choices` to draw from all possible k-combinations. - Each combination is then locally shuffled to remove ordering biases. """ all_combinations = list(combinations(range(0, num_images), k)) random.seed(seed) sampled_combinations = [list(x) for x in random.choices(all_combinations, k=N)] for i, tuple_ in enumerate(sampled_combinations): # Use a unique seed for each shuffle to ensure reproducibility random.seed(seed + i) random.shuffle(tuple_) return sampled_combinations class MVLSIBConfig(datasets.BuilderConfig): """ Configuration class for the MVLSIB (Multilingual Visual Language SIB) dataset. Parameters ---------- name : str The configuration name, typically in the format "task.lang". upsampling_factor : int, optional How many times to replicate each row for additional sampling variety, default: 3. num_references : int, optional Number of positive references to sample for each row, default: 5. num_negatives : int, optional Number of negative samples to pair with each row, default: 3. seed : int, optional Seed for random operations, default: 42. """ def __init__( self, name: str, upsampling_factor: int = UPSAMPLING_FACTOR, num_references: int = NUM_REFERENCES, num_negatives: int = NUM_NEGATIVES, seed: int = SEED, **kwargs: Any, ): super(MVLSIBConfig, self).__init__(**kwargs) self.name: str = name self.task, self.lang = name.split(".") self.upsampling_factor: int = upsampling_factor self.num_references: int = num_references self.num_negatives: int = num_negatives self.seed: int = seed def _builder_configs() -> List[MVLSIBConfig]: """ Internal helper to build the list of MVLSIBConfig objects for all tasks ('img2sent', 'sent2img') and all available languages in LANGS. Returns ------- List[MVLSIBConfig] A list of dataset configuration objects, each specifying a (task, language) pair. """ configs: List[MVLSIBConfig] = [] for task in ("img2sent", "sent2img"): for lang in LANGS: cfg = MVLSIBConfig( name=f"{task}.{lang}", version=datasets.Version("1.0.0"), description=f"MVLSIB: {task}.{lang}", ) configs.append(cfg) return configs class MVLSIB(datasets.GeneratorBasedBuilder): """ MVLSIB is a multilingual dataset that provides matched (sentence -> image) or (image -> sentence) examples for classification or retrieval tasks. Each configuration is specified by a task (img2sent or sent2img) and a language code, e.g. 'img2sent.eng_Latn'. The dataset is structured such that each row includes: - A set of reference items (images or sentences, depending on the task). - A set of 4 possible answers (1 positive, 3 negative). - A prompt instructing the user to pick the correct match. - A label indicating which of the 4 answers is correct. """ BUILDER_CONFIGS = _builder_configs() BUILDER_CONFIG_CLASS = MVLSIBConfig def _info(self) -> datasets.DatasetInfo: """ Returns the dataset metadata, including features. The dataset has two major tasks: - 'img2sent': Given reference images, choose the best matching sentence. - 'sent2img': Given reference sentences, choose the best matching image. Each example row in 'img2sent' includes: - images (list of str URLs to images) - sentences (list of str, one positive, three negatives) - categories (list of str categories matching each sentence) - label (int specifying which of the sentences is correct) - id (an integer ID) - index_id (the original row ID from the SIB .tsv) - prompt (str, the classification prompt) Each example row in 'sent2img' includes: - sentences (list of str, the positive reference sentences) - images (list of str URLs to images, one positive, three negatives) - categories (list of str categories matching each image) - label (int specifying which of the images is correct) - id (an integer ID) - index_id (the original row ID from the SIB .tsv) - prompt (str, the classification prompt) Returns ------- datasets.DatasetInfo The Hugging Face DatasetInfo object describing the dataset features, licensing, homepage, citation, etc. """ from datasets import DatasetInfo, Features, Sequence, Value img2sents = Features( { "images": Sequence(Value("string")), "sentences": Sequence(Value("string")), "categories": Sequence(Value("string")), "prompt": Value("string"), "label": Value("int8"), "id": Value("int64"), "index_id": Value("int64"), } ) sent2imgs = Features( { "sentences": Sequence(Value("string")), "images": Sequence(Value("string")), "categories": Sequence(Value("string")), "label": Value("int8"), "id": Value("int64"), "index_id": Value("int64"), "prompt": Value("string"), } ) features = { "img2sent": img2sents, "sent2img": sent2imgs, } return DatasetInfo( description=_DESCRIPTION, features=features[self.config.task], supervised_keys=None, ) def _split_generators( self, dl_manager: datasets.DownloadManager, *args: Any, **kwargs: Any ) -> List[datasets.SplitGenerator]: """ Defines the splits of the dataset. In this case, we only produce a single 'test' split, but in principle, you can define train/dev/test or others. Parameters ---------- dl_manager : datasets.DownloadManager The Hugging Face DownloadManager used to download files. Returns ------- List[datasets.SplitGenerator] A list of SplitGenerator objects. Each defines a split name and a gen_kwargs dict for the `_generate_examples` method. """ # Download SIB tsv files for train, dev, and test files = dl_manager.download( [ _SIB_URL.format(lang=self.config.lang, split=split) for split in ("train", "dev", "test") ] ) # Download images for each category images: Dict[str, List[str]] = {} for cat in CATEGORIES: images[cat] = [] for i in range(10): images[cat].append( dl_manager.download(_IMG_URL.format(category=cat, no=i)) ) return [ datasets.SplitGenerator( name="test", gen_kwargs={"sib_filepaths": files, "images_filepaths": images}, ), ] def _generate_examples( self, sib_filepaths: List[str], images_filepaths: Dict[str, List[str]], *args: Any, **kwargs: Any, ) -> Any: """ Generator function that yields dataset examples in the format needed by Hugging Face Datasets. Depending on the task (img2sent or sent2img), the function constructs examples where: - img2sent: reference images, 4 candidate sentences (1 positive, 3 negative) - sent2img: reference sentences, 4 candidate images (1 positive, 3 negative) Parameters ---------- sib_filepaths : List[str] The downloaded .tsv file paths (train/dev/test) for the specified language. images_filepaths : Dict[str, List[str]] A dictionary from category -> list of 10 image URLs, as downloaded from `_split_generators`. Yields ------ Tuple[int, Dict[str, Any]] A tuple where the first element is an integer index, and the second is a dictionary matching the features specification of the dataset. """ # Read the SIB .tsv files for the given language and combine into a single DataFrame records = read_lang_tsv(sib_filepaths) df = pd.DataFrame.from_records(records) # Expand the dataset with negative and positive samples ext_df = replicate_and_negatives( df, num_replicates=self.config.upsampling_factor, num_negatives=self.config.num_negatives, # every line already has a positive num_positives=self.config.num_references - 1, seed=self.config.seed, ) sent_ids = list(range(self.config.num_negatives + 1)) N = len(ext_df) num_images = len(next(iter(images_filepaths.values()))) # e.g., 10 images/cat if self.config.task == "img2sent": # Pre-generate image ID combinations for each row image_ids = get_reference_image_ids( N=N, num_images=num_images, k=self.config.num_references, seed=self.config.seed, ) for i, row in ext_df.iterrows(): # Construct the list of candidate sentences (pos + neg) text = [row["text"]] categories = [row["category"]] for j in range(self.config.num_negatives): text.append(row[f"neg_text_{j}"]) categories.append(row[f"neg_cat_{j}"]) # Shuffle candidate sentences in a reproducible manner random.seed(i) random.shuffle(sent_ids) label = sent_ids[0] # Reorder sentences and categories according to the shuffled indices _, categories_shuffled = zip(*sorted(zip(sent_ids, categories))) _, sentences_shuffled = zip(*sorted(zip(sent_ids, text))) # Fetch the reference images for the row row_image_ids = image_ids[i] cat = row["category"] cat_images = images_filepaths[cat] row_images = [ cat_images[row_image_ids[j]] for j in range(self.config.num_references) ] yield ( i, { "id": i, "prompt": IMG2SENT_PROMPT, "index_id": row["index_id"], "images": row_images, "categories": categories_shuffled, "sentences": sentences_shuffled, "label": label, }, ) else: # sent2img: We first sample image indices (pos + neg) for each row rng = np.random.default_rng(seed=self.config.seed) choice_image_ids = rng.integers( 0, num_images, (N, 1 + self.config.num_negatives) ).tolist() for i, row in ext_df.iterrows(): # The positive text pos_text = [row["text"]] # For the negative categories, we gather them similarly cats = [row["category"]] for j in range(self.config.num_negatives): cats.append(row[f"neg_cat_{j}"]) for j in range(self.config.num_references - 1): pos_text.append(row[f"pos_text_{j}"]) random.seed(i) random.shuffle(sent_ids) label = sent_ids[0] # Reorder categories based on the shuffled indices # NOTE: positive text is quasi-shuffled already _, categories_shuffled = zip(*sorted(zip(sent_ids, cats))) import pudb pu.db # Match the categories to the sampled image indices row_image_ids = choice_image_ids[i] row_images = [ images_filepaths[cat][idx] for idx, cat in zip(row_image_ids, categories_shuffled) ] yield ( i, { "id": i, "prompt": SENT2IMG_PROMPT, "index_id": row["index_id"], "images": row_images, "categories": categories_shuffled, "sentences": pos_text, "label": label, }, )