evalscope 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

evalscope/backend/rag_eval/clip_benchmark/dataset_builder.py

@@ -1,8 +1,9 @@
 import os
 import torch
-from torch.utils.data import DataLoader, Dataset as TorchDataset
-from evalscope.utils.logger import get_logger
+from torch.utils.data import DataLoader
+from torch.utils.data import Dataset as TorchDataset
 
+from evalscope.utils.logger import get_logger
 
 logger = get_logger()
 
@@ -11,7 +12,7 @@ def build_dataset(
     dataset_name,
     root=None,
     transform=None,
-    split="test",
+    split='test',
     wds_cache_dir=None,
     **kwargs,
 ):
@@ -40,9 +41,9 @@ def build_dataset(
 
     """
 
-    if dataset_name == "dummy":
+    if dataset_name == 'dummy':
         ds = Dummy()
-    elif dataset_name == "custom":
+    elif dataset_name == 'custom':
         ds = build_custom_dataset(dataset_name, data_dir=root, transform=transform)
     else:
         # WebDataset support using `webdataset` library
@@ -60,7 +61,7 @@ def build_dataset(
 class Dummy:
 
     def __init__(self):
-        self.classes = ["blank image", "noisy image"]
+        self.classes = ['blank image', 'noisy image']
 
     def __getitem__(self, i):
         return torch.zeros(3, 224, 224), 0
@@ -70,7 +71,8 @@ class Dummy:
 
 
 class DatasetWrapper(TorchDataset):
-    def __init__(self, dataset, transform=None, image_key="image", text_key="query"):
+
+    def __init__(self, dataset, transform=None, image_key='image', text_key='query'):
         self.dataset = dataset
         self.transform = transform
         self.image_key = image_key
@@ -85,7 +87,7 @@ class DatasetWrapper(TorchDataset):
         # 加载图像
         image = item[self.image_key]
         if self.transform is not None:
-            image = self.transform(image, return_tensors="pt")
+            image = self.transform(image, return_tensors='pt')
 
         # 获取查询列表
         query = item[self.text_key]
@@ -97,24 +99,24 @@ class DatasetWrapper(TorchDataset):
 
 def get_dataset_default_task(dataset):
     if dataset in (
-        "custom",
-        "muge",
-        "flickr30k",
-        "flickr8k",
-        "mscoco_captions",
-        "mscoco_captions2017",
-        "multilingual_mscoco_captions",
-        "flickr30k-200",
-        "crossmodal3600",
-        "xtd200",
+            'custom',
+            'muge',
+            'flickr30k',
+            'flickr8k',
+            'mscoco_captions',
+            'mscoco_captions2017',
+            'multilingual_mscoco_captions',
+            'flickr30k-200',
+            'crossmodal3600',
+            'xtd200',
     ):
-        return "zeroshot_retrieval"
+        return 'zeroshot_retrieval'
     else:
-        return "zeroshot_classification"
+        return 'zeroshot_classification'
 
 
 def get_dataloader(dataset_name, dataset, batch_size, num_workers):
-    if dataset_name == "custom":
+    if dataset_name == 'custom':
         dataloader = DataLoader(
             dataset,
             batch_size=batch_size,
@@ -140,26 +142,23 @@ def image_captions_collate_fn(batch):
 
 
 def build_custom_dataset(dataset_name, data_dir, transform=None):
-    from datasets import load_dataset, Features, Image, Sequence, Value
+    from datasets import Features, Image, Sequence, Value, load_dataset
 
     qrels_ds = load_dataset(
-        "json",
-        data_files=os.path.join(data_dir, "image_queries.jsonl"),
-        features=Features(
-            {"image_path": Image(decode=True), "query": Sequence(Value("string"))}
-        ),
-        split="train",
+        'json',
+        data_files=os.path.join(data_dir, 'image_queries.jsonl'),
+        features=Features({
+            'image_path': Image(decode=True),
+            'query': Sequence(Value('string'))
+        }),
+        split='train',
     )
 
-    dataset = DatasetWrapper(
-        qrels_ds, transform, image_key="image_path", text_key="query"
-    )
+    dataset = DatasetWrapper(qrels_ds, transform, image_key='image_path', text_key='query')
     return dataset
 
 
-def build_wds_dataset(
-    dataset_name, transform, split="test", data_dir="root", cache_dir=None
-):
+def build_wds_dataset(dataset_name, transform, split='test', data_dir='root', cache_dir=None):
     """
     Load a dataset in WebDataset format. Either local paths or HTTP URLs can be specified.
     Expected file structure is:
@@ -190,41 +189,39 @@ def build_wds_dataset(
     import webdataset as wds
 
     def read_txt(fname):
-        if "://" in fname:
-            stream = os.popen("curl -L -s --fail '%s'" % fname, "r")
+        if '://' in fname:
+            stream = os.popen("curl -L -s --fail '%s'" % fname, 'r')
             value = stream.read()
             if stream.close():
-                raise FileNotFoundError("Failed to retreive data")
+                raise FileNotFoundError('Failed to retreive data')
         else:
-            with open(fname, "r") as file:
+            with open(fname, 'r') as file:
                 value = file.read()
         return value
 
     if not data_dir:
-        data_dir = f"https://modelscope.cn/datasets/clip-benchmark/wds_{dataset_name}/resolve/master"
+        data_dir = f'https://modelscope.cn/datasets/clip-benchmark/wds_{dataset_name}/resolve/master'
 
     # Git LFS files have a different file path to access the raw data than other files
-    if data_dir.startswith("https://modelscope.cn/datasets"):
-        *split_url_head, _, url_path = data_dir.split("/", 7)
-        url_head = "/".join(split_url_head)
-        metadata_dir = "/".join([url_head, "resolve", url_path])
-        tardata_dir = "/".join([url_head, "resolve", url_path])
+    if data_dir.startswith('https://modelscope.cn/datasets'):
+        *split_url_head, _, url_path = data_dir.split('/', 7)
+        url_head = '/'.join(split_url_head)
+        metadata_dir = '/'.join([url_head, 'resolve', url_path])
+        tardata_dir = '/'.join([url_head, 'resolve', url_path])
     else:
         metadata_dir = tardata_dir = data_dir
     # Get number of shards
-    nshards_fname = os.path.join(metadata_dir, split, "nshards.txt")
-    nshards = int(
-        read_txt(nshards_fname)
-    )  # Do not catch FileNotFound, nshards.txt should be mandatory
-    
+    nshards_fname = os.path.join(metadata_dir, split, 'nshards.txt')
+    nshards = int(read_txt(nshards_fname))  # Do not catch FileNotFound, nshards.txt should be mandatory
+
     # Get dataset type (classification or retrieval)
-    type_fname = os.path.join(metadata_dir, "dataset_type.txt")
+    type_fname = os.path.join(metadata_dir, 'dataset_type.txt')
     try:
         dataset_type = read_txt(type_fname).strip().lower()
     except FileNotFoundError:
-        dataset_type = "classification"
-    
-    filepattern = os.path.join(tardata_dir, split, "{0..%d}.tar" % (nshards - 1))
+        dataset_type = 'classification'
+
+    filepattern = os.path.join(tardata_dir, split, '{0..%d}.tar' % (nshards - 1))
     # Load webdataset (support WEBP, PNG, and JPG for now)
     if not cache_dir or not isinstance(cache_dir, str):
         cache_dir = None
@@ -236,42 +233,28 @@ def build_wds_dataset(
         nodesplitter=lambda src: src,
         shardshuffle=False,
         verbose=True,
-    ).decode(
-        wds.autodecode.ImageHandler("pil", extensions=["webp", "png", "jpg", "jpeg"])
-    )
-    
+    ).decode(wds.autodecode.ImageHandler('pil', extensions=['webp', 'png', 'jpg', 'jpeg']))
+
     # Load based on classification or retrieval task
-    if dataset_type == "retrieval":
-        dataset = dataset.to_tuple(["webp", "png", "jpg", "jpeg"], "txt").map_tuple(
-            transform, str.splitlines
-        )
+    if dataset_type == 'retrieval':
+        dataset = dataset.to_tuple(['webp', 'png', 'jpg', 'jpeg'], 'txt').map_tuple(transform, str.splitlines)
         dataset.classes = dataset.templates = None
     else:
-        label_type = (
-            "npy" if dataset_type == "multilabel" else "cls"
-        )  # Special case for multilabel
-        dataset = dataset.to_tuple(
-            ["webp", "png", "jpg", "jpeg"], label_type
-        ).map_tuple(transform, None)
+        label_type = ('npy' if dataset_type == 'multilabel' else 'cls')  # Special case for multilabel
+        dataset = dataset.to_tuple(['webp', 'png', 'jpg', 'jpeg'], label_type).map_tuple(transform, None)
         # Get class names if present
-        classnames_fname = os.path.join(metadata_dir, "classnames.txt")
+        classnames_fname = os.path.join(metadata_dir, 'classnames.txt')
         try:
-            dataset.classes = [
-                line.strip() for line in read_txt(classnames_fname).splitlines()
-            ]
+            dataset.classes = [line.strip() for line in read_txt(classnames_fname).splitlines()]
         except FileNotFoundError:
-            logger.warning("WARNING: classnames.txt not found")
+            logger.warning('WARNING: classnames.txt not found')
             dataset.classes = None
         # Get zeroshot classification templates if present
-        templates_fname = os.path.join(
-            metadata_dir, "zeroshot_classification_templates.txt"
-        )
+        templates_fname = os.path.join(metadata_dir, 'zeroshot_classification_templates.txt')
         try:
-            dataset.templates = [
-                line.strip() for line in read_txt(templates_fname).splitlines()
-            ]
+            dataset.templates = [line.strip() for line in read_txt(templates_fname).splitlines()]
         except FileNotFoundError:
-            logger.warning("WARNING: zeroshot_classification_templates.txt not found")
+            logger.warning('WARNING: zeroshot_classification_templates.txt not found')
             dataset.templates = None
 
     return dataset

evalscope/backend/rag_eval/clip_benchmark/task_template.py

@@ -1,19 +1,12 @@
+import json
 import os
 import torch
-import json
 from itertools import product
 
-from evalscope.backend.rag_eval.clip_benchmark.dataset_builder import (
-    build_dataset,
-    get_dataset_default_task,
-    get_dataloader,
-)
-from evalscope.backend.rag_eval.clip_benchmark.tasks import (
-    zeroshot_classification,
-    zeroshot_retrieval,
-    image_caption,
-)
 from evalscope.backend.rag_eval.clip_benchmark.arguments import Arguments
+from evalscope.backend.rag_eval.clip_benchmark.dataset_builder import (build_dataset, get_dataloader,
+                                                                       get_dataset_default_task)
+from evalscope.backend.rag_eval.clip_benchmark.tasks import image_caption, zeroshot_classification, zeroshot_retrieval
 from evalscope.backend.rag_eval.utils.clip import VisionModel
 from evalscope.utils.logger import get_logger
 
@@ -37,21 +30,21 @@ def evaluate(args: Arguments):
     # Iterate over model and dataset combinations
     for model_cfg, dataset_name in product(models, dataset_names):
         task = input_task or get_dataset_default_task(dataset_name)
-        model_name = os.path.basename(model_cfg["model_name"])
+        model_name = os.path.basename(model_cfg['model_name'])
 
         output_path = os.path.join(output_dir, model_name)
         os.makedirs(output_path, exist_ok=True)
-        output_file = os.path.join(output_path, f"{dataset_name}_{task}.json")
+        output_file = os.path.join(output_path, f'{dataset_name}_{task}.json')
 
         # Skip evaluation if the result already exists and skip_existing is True
         if os.path.exists(output_file) and skip_existing:
             if verbose:
-                logger.info(f"Skip {output_dir}, exists already.")
+                logger.info(f'Skip {output_dir}, exists already.')
             return
 
         # Determine device (CPU or GPU)
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        model_cfg["device"] = device
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        model_cfg['device'] = device
         # Initialize the model
         model = VisionModel.load(**model_cfg)
 
@@ -61,23 +54,20 @@ def evaluate(args: Arguments):
             root=data_dir,
             transform=model.transform,
             split=split,
-            wds_cache_dir=f"{cache_dir}/{dataset_name}",
+            wds_cache_dir=f'{cache_dir}/{dataset_name}',
         )
 
         # Create the dataloader
         dataloader = get_dataloader(dataset_name, dataset, batch_size, num_workers)
 
         # Evaluate based on the task
-        if task == "zeroshot_classification":
-            zeroshot_templates = (
-                dataset.templates if hasattr(dataset, "templates") else None
-            )
+        if task == 'zeroshot_classification':
+            zeroshot_templates = (dataset.templates if hasattr(dataset, 'templates') else None)
             if verbose:
-                logger.info(f"Zero-shot templates: {zeroshot_templates}")
-            classnames = dataset.classes if hasattr(dataset, "classes") else None
-            assert (
-                zeroshot_templates is not None and classnames is not None
-            ), "Dataset does not support classification"
+                logger.info(f'Zero-shot templates: {zeroshot_templates}')
+            classnames = dataset.classes if hasattr(dataset, 'classes') else None
+            assert (zeroshot_templates is not None
+                    and classnames is not None), 'Dataset does not support classification'
             metrics = zeroshot_classification.evaluate(
                 model,
                 dataloader,
@@ -87,33 +77,29 @@ def evaluate(args: Arguments):
                 verbose=verbose,
                 limit=limit,
             )
-        elif task == "zeroshot_retrieval":
-            metrics = zeroshot_retrieval.evaluate(
-                model, dataloader, recall_k_list=[5], device=device, limit=limit
-            )
-        elif task == "image_caption":
-            output_path = os.path.join(output_path, dataset_name, "retrieval_data")
-            metrics = image_caption.evaluate(
-                model, dataloader, limit=limit, output_path=output_path
-            )
+        elif task == 'zeroshot_retrieval':
+            metrics = zeroshot_retrieval.evaluate(model, dataloader, recall_k_list=[5], device=device, limit=limit)
+        elif task == 'image_caption':
+            output_path = os.path.join(output_path, dataset_name, 'retrieval_data')
+            metrics = image_caption.evaluate(model, dataloader, limit=limit, output_path=output_path)
 
         # Prepare dump data
         dump = {
-            "dataset": dataset_name,
-            "model": model_name,
-            "task": task,
-            "metrics": metrics,
+            'dataset': dataset_name,
+            'model': model_name,
+            'task': task,
+            'metrics': metrics,
         }
 
         if verbose:
-            logger.info(f"Evaluation results: {dump}")
+            logger.info(f'Evaluation results: {dump}')
 
         # Write the results to output file
         if verbose:
-            logger.info(f"Dump results to: {output_file}")
-        with open(output_file, "w") as f:
+            logger.info(f'Dump results to: {output_file}')
+        with open(output_file, 'w') as f:
             json.dump(dump, f)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     evaluate()

evalscope/backend/rag_eval/clip_benchmark/tasks/image_caption.py

@@ -1,14 +1,14 @@
-from tqdm import tqdm
-import pandas as pd
 import os
-from evalscope.backend.rag_eval.utils.tools import save_to_jsonl, save_to_tsv
+import pandas as pd
+from tqdm import tqdm
 
+from evalscope.backend.rag_eval.utils.tools import save_to_jsonl, save_to_tsv
 from evalscope.utils.logger import get_logger
 
 logger = get_logger()
 
 
-def evaluate(model, dataloader, limit=None, output_path=""):
+def evaluate(model, dataloader, limit=None, output_path=''):
     """
     Evaluate the model on the dataset
     Parameters
@@ -31,9 +31,7 @@ def evaluate(model, dataloader, limit=None, output_path=""):
         captions = model.encode_image(batch_images)
         querys = [text for texts in batch_texts for text in texts]
 
-        batch_texts_image_index = [
-            ind for ind, texts in zip(inds, batch_texts) for text in texts
-        ]
+        batch_texts_image_index = [ind for ind, texts in zip(inds, batch_texts) for text in texts]
 
         total_captions.extend(captions)
         total_querys.extend(querys)
@@ -47,30 +45,30 @@ def evaluate(model, dataloader, limit=None, output_path=""):
                 break
 
     write_file(total_querys, total_captions, query_caption_index, output_path)
-    return {"convertion_successful": True, "save_path": output_path}
+    return {'convertion_successful': True, 'save_path': output_path}
 
 
 def write_file(query_list, corpus_list, qrels_list, output_path):
     # 处理 query_list
-    query_df = pd.DataFrame(query_list, columns=["text"])
-    query_df["_id"] = query_df.index
-    query_df = query_df[["_id", "text"]]
-    save_to_jsonl(query_df, os.path.join(output_path, "queries.jsonl"))
+    query_df = pd.DataFrame(query_list, columns=['text'])
+    query_df['_id'] = query_df.index
+    query_df = query_df[['_id', 'text']]
+    save_to_jsonl(query_df, os.path.join(output_path, 'queries.jsonl'))
 
     # 处理 corpus_list
-    corpus_df = pd.DataFrame(corpus_list, columns=["text"])
-    corpus_df["_id"] = corpus_df.index
-    corpus_df = corpus_df[["_id", "text"]]
-    save_to_jsonl(corpus_df, os.path.join(output_path, "corpus.jsonl"))
+    corpus_df = pd.DataFrame(corpus_list, columns=['text'])
+    corpus_df['_id'] = corpus_df.index
+    corpus_df = corpus_df[['_id', 'text']]
+    save_to_jsonl(corpus_df, os.path.join(output_path, 'corpus.jsonl'))
 
     # 处理 qrels_list
-    qrels_df = pd.DataFrame(qrels_list, columns=["corpus-id"])
-    qrels_df["query-id"] = qrels_df.index
-    qrels_df["score"] = 1
-    qrels_df = qrels_df[["query-id", "corpus-id", "score"]]
-    save_to_tsv(qrels_df, os.path.join(output_path, "qrels", "test.tsv"))
+    qrels_df = pd.DataFrame(qrels_list, columns=['corpus-id'])
+    qrels_df['query-id'] = qrels_df.index
+    qrels_df['score'] = 1
+    qrels_df = qrels_df[['query-id', 'corpus-id', 'score']]
+    save_to_tsv(qrels_df, os.path.join(output_path, 'qrels', 'test.tsv'))
 
-    logger.info("Write files to {}".format(output_path))
+    logger.info('Write files to {}'.format(output_path))
     return
 
 

evalscope/backend/rag_eval/clip_benchmark/tasks/zeroshot_classification.py

@@ -4,14 +4,12 @@ Thanks to the authors of OpenCLIP
 """
 
 import logging
-from contextlib import suppress
-
 import torch
 import torch.nn.functional as F
+from contextlib import suppress
+from sklearn.metrics import balanced_accuracy_score, classification_report
 from tqdm import tqdm
 
-from sklearn.metrics import classification_report, balanced_accuracy_score
-
 from evalscope.utils.logger import get_logger
 
 logger = get_logger()
@@ -49,7 +47,7 @@ def zero_shot_classifier(model, classnames, templates, device, amp=True):
                 # generic prompts tht are specialized for each class by replacing {c} with the class name
                 texts = [template.format(c=classname) for template in templates]
             else:
-                raise ValueError("templates must be a list or a dict")
+                raise ValueError('templates must be a list or a dict')
             class_embedding = model.encode_text(texts).mean(dim=0)
             class_embedding = F.normalize(class_embedding, dim=0)
             zeroshot_weights.append(class_embedding)
@@ -57,7 +55,7 @@ def zero_shot_classifier(model, classnames, templates, device, amp=True):
     return zeroshot_weights
 
 
-def accuracy(output, target, topk=(1,)):
+def accuracy(output, target, topk=(1, )):
     """
     Compute top-k accuracy
 
@@ -79,10 +77,7 @@ def accuracy(output, target, topk=(1,)):
     pred = output.topk(max(topk), 1, True, True)[1].t()
     correct = pred.eq(target.view(1, -1).expand_as(pred))
     n = len(target)
-    return [
-        float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy()) / n
-        for k in topk
-    ]
+    return [float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy()) / n for k in topk]
 
 
 def run_classification(model, classifier, dataloader, device, amp=True, limit=None):
@@ -115,7 +110,7 @@ def run_classification(model, classifier, dataloader, device, amp=True, limit=No
                 # predict
                 image_features = model.encode_image(images)
                 logits = 100.0 * image_features @ classifier
-            
+
             if limit is not None:
                 # Update sample counter
                 sample_count += len(images)
@@ -217,15 +212,13 @@ def evaluate(
 
     if is_multilabel:
         if verbose:
-            logger.info("Detected a multi-label classification dataset")
+            logger.info('Detected a multi-label classification dataset')
         # Multiple labels per image, multiple classes on the dataset
         ap_per_class = average_precision_per_class(logits, target)
         if verbose:
-            for class_name, ap in zip(
-                dataloader.dataset.classes, ap_per_class.tolist()
-            ):
-                logger.info(f"Class: {class_name}, AveragePrecision: {ap}")
-        return {"mean_average_precision": ap_per_class.mean().item()}
+            for class_name, ap in zip(dataloader.dataset.classes, ap_per_class.tolist()):
+                logger.info(f'Class: {class_name}, AveragePrecision: {ap}')
+        return {'mean_average_precision': ap_per_class.mean().item()}
     else:
         # Single label per image, multiple classes on the dataset
         # just compute accuracy and mean_per_class_recall
@@ -235,13 +228,13 @@ def evaluate(
         if len(dataloader.dataset.classes) >= 5:
             acc1, acc5 = accuracy(logits, target, topk=(1, 5))
         else:
-            (acc1,) = accuracy(logits, target, topk=(1,))
-            acc5 = float("nan")
+            (acc1, ) = accuracy(logits, target, topk=(1, ))
+            acc5 = float('nan')
         mean_per_class_recall = balanced_accuracy_score(target, pred)
         if verbose:
-            logger.info("\n" + classification_report(target, pred, digits=3))
+            logger.info('\n' + classification_report(target, pred, digits=3))
         return {
-            "acc1": acc1,
-            "acc5": acc5,
-            "mean_per_class_recall": mean_per_class_recall,
+            'acc1': acc1,
+            'acc5': acc5,
+            'mean_per_class_recall': mean_per_class_recall,
         }

evalscope/backend/rag_eval/clip_benchmark/tasks/zeroshot_retrieval.py

@@ -1,9 +1,9 @@
 import logging
-from contextlib import suppress
-
 import torch
 import torch.nn.functional as F
+from contextlib import suppress
 from tqdm import tqdm
+
 from evalscope.utils.logger import get_logger
 
 logger = get_logger()
@@ -51,9 +51,7 @@ def evaluate(model, dataloader, device, amp=True, recall_k_list=[5], limit=None)
     for batch_images, batch_texts, inds in tqdm(dataloader):
 
         # store the index of image for each text
-        batch_texts_image_index = [
-            ind for ind, texts in zip(inds, batch_texts) for text in texts
-        ]
+        batch_texts_image_index = [ind for ind, texts in zip(inds, batch_texts) for text in texts]
 
         # compute the embedding of images and texts
         batch_images_emb = model.encode_image(batch_images)
@@ -93,33 +91,16 @@ def evaluate(model, dataloader, device, amp=True, recall_k_list=[5], limit=None)
         # so we can easily compute that using the actual recall, by checking whether there is at least one true positive,
         # which would be the case if the recall is greater than 0. One we compute the recal for each image (or text), we average
         # it over the dataset.
-        metrics[f"image_retrieval_recall@{recall_k}"] = (
-            (
-                batchify(
-                    recall_at_k, scores, positive_pairs, batch_size, device, k=recall_k
-                )
-                > 0
-            )
-            .float()
-            .mean()
-            .item()
-        )
-        metrics[f"text_retrieval_recall@{recall_k}"] = (
-            (
-                batchify(
-                    recall_at_k,
-                    scores.T,
-                    positive_pairs.T,
-                    batch_size,
-                    device,
-                    k=recall_k,
-                )
-                > 0
-            )
-            .float()
-            .mean()
-            .item()
-        )
+        metrics[f'image_retrieval_recall@{recall_k}'] = ((batchify(
+            recall_at_k, scores, positive_pairs, batch_size, device, k=recall_k) > 0).float().mean().item())
+        metrics[f'text_retrieval_recall@{recall_k}'] = ((batchify(
+            recall_at_k,
+            scores.T,
+            positive_pairs.T,
+            batch_size,
+            device,
+            k=recall_k,
+        ) > 0).float().mean().item())
 
     return metrics
 
@@ -147,9 +128,7 @@ def recall_at_k(scores, positive_pairs, k):
     # compute number of positives for each text
     nb_positive = positive_pairs.sum(dim=1)
     # nb_texts, k, nb_images
-    topk_indices_onehot = torch.nn.functional.one_hot(
-        topk_indices, num_classes=nb_images
-    )
+    topk_indices_onehot = torch.nn.functional.one_hot(topk_indices, num_classes=nb_images)
     # compute number of true positives
     positive_pairs_reshaped = positive_pairs.view(nb_texts, 1, nb_images)
     # a true positive means a positive among the topk