chore: copy mvl-sib200.py to mvl-sib.py

mvl-sib.py

@@ -0,0 +1,706 @@
+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",
+]
+
+# URLs for downloading SIB .tsv data and images.
+_SIB_URL: str = "https://huggingface.co/datasets/wuenlp/mvl-sib200/resolve/main/data/sib200/{lang}/{split}.tsv"
+_IMG_URL: str = "https://huggingface.co/datasets/wuenlp/mvl-sib200/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):
+            #
+            if all(
+                (row[key].strip() == key) or (row[key].strip() == "")
+                for key in expected_headers
+            ):
+                continue
+            # 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 = 3,
+    num_negatives: int = 4,
+    num_positives: int = 4,
+    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 is different
+    from the row's category. **Additionally, each negative example for
+    a given row is drawn from a distinct category among the negatives,
+    if there are enough categories to do so without replacement.**
+
+    *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_negatives-1]
+        - pos_id_i, pos_cat_i, pos_text_i for i in [0 .. num_positives-1]
+
+    Notes
+    -----
+    - Negative examples for a row are taken from distinct categories
+      (other than the row's category) if enough categories exist. If
+      fewer categories exist than `num_negatives`, we sample categories
+      with replacement, so some duplicates may appear.
+    - Positive sampling excludes the row's own 'index_id'.
+      If there are fewer available positives than `num_positives`,
+      we sample with replacement.
+    """
+
+    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
+
+    # --- Precompute a dictionary of all rows by category (for negatives sampling) ---
+    # Key: category -> DataFrame of that category
+    unique_cats = df_new["category"].unique()
+    cat_to_df: Dict[str, pd.DataFrame] = {}
+    for c in unique_cats:
+        cat_to_df[c] = df_new[df_new["category"] == c].reset_index(drop=True)
+
+    # --- 4) Build a "positive pool" dictionary by category ---
+    # For positive sampling, we exclude the row's own 'index_id' in each row's step
+    pos_pool_by_cat = {}
+    for c in unique_cats:
+        pos_pool_by_cat[c] = df.loc[
+            df["category"] == c, ["index_id", "category", "text"]
+        ].reset_index(drop=True)
+
+    # --- 5) Group df_new by category and populate negative/positive samples ---
+    grouped = df_new.groupby("category", group_keys=False)
+    output_chunks: List[pd.DataFrame] = []
+
+    for cat, group_df in grouped:
+        g_size = len(group_df)
+
+        # The preallocated arrays for negative and positive columns will be filled for each row individually, i.e., sampling of negative categories and samples will be done per row
+        # Prepare arrays for final negative columns
+        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)]
+
+        # Prepare arrays for final positive columns
+        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)]
+
+        # For convenience, get all categories *except* the current one (cat)
+        # We'll sample from these as negative categories
+        negative_candidate_cats = [c for c in unique_cats if c != cat]
+
+        # For each row in the current group
+        row_ids_for_group = group_df["index_id"].to_numpy()
+        for i_row in range(g_size):
+            row_id = row_ids_for_group[i_row]
+
+            # ------------- Negative Sampling -------------
+            # 1) Choose distinct categories if possible. If not enough categories
+            #    exist to cover num_negatives, we sample categories with replacement.
+            replace_for_cats = len(negative_candidate_cats) < num_negatives
+            chosen_neg_cats = rng.choice(
+                negative_candidate_cats, size=num_negatives, replace=replace_for_cats
+            )
+
+            # 2) For each chosen negative category, pick a random row
+            for j, neg_cat in enumerate(chosen_neg_cats):
+                neg_pool = cat_to_df[neg_cat]
+                pick_idx = rng.integers(len(neg_pool))  # random index
+                neg_id_cols[j][i_row] = neg_pool["index_id"].iloc[pick_idx]
+                neg_cat_cols[j][i_row] = neg_pool["category"].iloc[pick_idx]
+                neg_text_cols[j][i_row] = neg_pool["text"].iloc[pick_idx]
+
+            # ------------- Positive Sampling -------------
+            pos_pool_cat = pos_pool_by_cat[cat]
+            # Exclude the row's own ID in the sampling
+            valid_mask = pos_pool_cat["index_id"] != row_id
+            valid_pos_pool = pos_pool_cat[valid_mask]
+            # If not enough positives remain, sample with replacement
+            replace_pos_for_row = len(valid_pos_pool) < num_positives
+
+            if len(valid_pos_pool) == 0:
+                # Edge case: if there's literally no other row of the same category,
+                # we won't be able to sample. You could decide to fill with NaN
+                # or replicate the single example. Here we do the "safe" approach
+                # of sampling from the entire cat's pool if possible.
+                valid_pos_pool = pos_pool_cat
+                replace_pos_for_row = True
+
+            valid_idx_array = valid_pos_pool.index.to_numpy()
+            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][i_row] = valid_pos_pool["index_id"].loc[pick_idx]
+                pos_cat_cols[j][i_row] = valid_pos_pool["category"].loc[pick_idx]
+                pos_text_cols[j][i_row] = valid_pos_pool["text"].loc[pick_idx]
+
+        # Attach negative columns to group_df
+        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]
+
+        # Attach positive columns to group_df
+        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 all chunks and restore 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 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)
+
+        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)
+
+        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")),
+                "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"),
+            }
+        )
+
+        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,
+                        "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)))
+
+                # 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,
+                        "index_id": row["index_id"],
+                        "images": row_images,
+                        "categories": categories_shuffled,
+                        "sentences": pos_text,
+                        "label": label,
+                    },
+                )