evalscope 0.17.1__py3-none-any.whl → 1.0.1__py3-none-any.whl

evalscope/metrics/t2v_metrics/models/vqascore_models/clip_t5/model/language_model/clip_t5.py

@@ -58,8 +58,9 @@ class CLIPT5ForConditionalGeneration(T5ForConditionalGeneration):
     def get_model(self):
         return self  # for compatibility with LlavaMetaForCausalLM
 
-    def prepare_inputs_labels_for_multimodal(self, input_ids, attention_mask, decoder_attention_mask, past_key_values,
-                                             labels, images):
+    def prepare_inputs_labels_for_multimodal(
+        self, input_ids, attention_mask, decoder_attention_mask, past_key_values, labels, images
+    ):
         # The labels are now separated from the input_ids.
         vision_tower = self.get_vision_tower()
         if vision_tower is None or images is None or input_ids.shape[1] == 1:
@@ -103,10 +104,12 @@ class CLIPT5ForConditionalGeneration(T5ForConditionalGeneration):
             _input_embeds_lengths = []
             for cur_new_embed in new_input_embeds:
                 _input_embeds_lengths.append(cur_new_embed.shape[0])
-                cur_new_embed = torch.cat((cur_new_embed,
-                                           torch.zeros((max_len - cur_new_embed.shape[0], cur_new_embed.shape[1]),
-                                                       dtype=cur_new_embed.dtype,
-                                                       device=cur_new_embed.device)),
+                cur_new_embed = torch.cat((
+                    cur_new_embed,
+                    torch.zeros((max_len - cur_new_embed.shape[0], cur_new_embed.shape[1]),
+                                dtype=cur_new_embed.dtype,
+                                device=cur_new_embed.device)
+                ),
                                           dim=0)
                 new_input_embeds_align.append(cur_new_embed)
             new_input_embeds = torch.stack(new_input_embeds_align, dim=0)
@@ -123,7 +126,8 @@ class CLIPT5ForConditionalGeneration(T5ForConditionalGeneration):
                                                          dtype=attention_mask.dtype,
                                                          device=attention_mask.device)
                     cur_new_attention_mask = torch.cat(
-                        (new_attn_mask_pad_left, cur_attention_mask, new_attn_mask_pad_right), dim=0)
+                        (new_attn_mask_pad_left, cur_attention_mask, new_attn_mask_pad_right), dim=0
+                    )
                     new_attention_mask.append(cur_new_attention_mask)
                 attention_mask = torch.stack(new_attention_mask, dim=0)
                 assert attention_mask.shape == new_input_embeds.shape[:2]
@@ -135,7 +139,8 @@ class CLIPT5ForConditionalGeneration(T5ForConditionalGeneration):
                     (attention_mask.shape[0], new_input_embeds.shape[1] - input_ids.shape[1]),
                     True,
                     dtype=attention_mask.dtype,
-                    device=attention_mask.device)
+                    device=attention_mask.device
+                )
                 attention_mask = torch.cat((new_attn_mask_pad_left, attention_mask), dim=1)
                 assert attention_mask.shape == new_input_embeds.shape[:2]
 
@@ -204,7 +209,8 @@ class CLIPT5ForConditionalGeneration(T5ForConditionalGeneration):
     ) -> Union[Tuple[torch.FloatTensor], Seq2SeqLMOutput]:
         output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
         output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states)
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
         return_dict = return_dict if return_dict is not None else self.config.use_return_dict
 
         if inputs_embeds is None:

evalscope/metrics/t2v_metrics/models/vqascore_models/clip_t5/model/multimodal_encoder/clip_encoder.py

@@ -44,12 +44,14 @@ class CLIPVisionTower(nn.Module):
             image_features = []
             for image in images:
                 image_forward_out = self.vision_tower(
-                    image.to(device=self.device, dtype=self.dtype).unsqueeze(0), output_hidden_states=True)
+                    image.to(device=self.device, dtype=self.dtype).unsqueeze(0), output_hidden_states=True
+                )
                 image_feature = self.feature_select(image_forward_out).to(image.dtype)
                 image_features.append(image_feature)
         else:
             image_forward_outs = self.vision_tower(
-                images.to(device=self.device, dtype=self.dtype), output_hidden_states=True)
+                images.to(device=self.device, dtype=self.dtype), output_hidden_states=True
+            )
             image_features = self.feature_select(image_forward_outs).to(images.dtype)
 
         return image_features

evalscope/metrics/t2v_metrics/models/vqascore_models/clip_t5_model.py

@@ -98,7 +98,8 @@ class CLIPT5Model(VQAScoreModel):
             mmprojector_repo=mmprojector_repo,
             mmprojector_name=mmprojector_name,
             device=self.device,
-            cache_dir=self.cache_dir)
+            cache_dir=self.cache_dir
+        )
 
     def load_images(self, image: List[str]) -> torch.Tensor:
         """Load the image(s), and return a tensor (after preprocessing) put on self.device
@@ -115,11 +116,13 @@ class CLIPT5Model(VQAScoreModel):
 
     @torch.no_grad()
     @torch.autocast(device_type='cuda', dtype=torch.bfloat16)
-    def forward(self,
-                images: List[str],
-                texts: List[str],
-                question_template: str = default_question_template,
-                answer_template: str = default_answer_template) -> torch.Tensor:
+    def forward(
+        self,
+        images: List[str],
+        texts: List[str],
+        question_template: str = default_question_template,
+        answer_template: str = default_answer_template
+    ) -> torch.Tensor:
         """Forward pass of the model to return n scores for n (image, text) pairs (in PyTorch Tensor)
         """
         assert len(images) == len(texts), 'Number of images and texts must match'
@@ -139,7 +142,8 @@ class CLIPT5Model(VQAScoreModel):
         labels = [t5_tokenizer_image_token(ans, self.tokenizer, return_tensors='pt') for ans in answers]
 
         input_ids = torch.nn.utils.rnn.pad_sequence(
-            input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id)
+            input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id
+        )
         labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=IGNORE_INDEX)
         input_ids = input_ids[:, :self.tokenizer.model_max_length]
         labels = labels[:, :self.tokenizer.model_max_length]
@@ -169,8 +173,8 @@ class CLIPT5Model(VQAScoreModel):
         lm_prob = torch.zeros(logits.shape[0])
         loss_fct = torch.nn.CrossEntropyLoss(reduction='mean')
         for k in range(lm_prob.shape[0]):
-            lm_prob[k] = (
-                -loss_fct(logits[k], labels[k])).exp()  # exp to cancel the log and get raw prob between 0 and 1
+            lm_prob[k] = (-loss_fct(logits[k],
+                                    labels[k])).exp()  # exp to cancel the log and get raw prob between 0 and 1
         return lm_prob
 
     @torch.no_grad()
@@ -191,7 +195,8 @@ class CLIPT5Model(VQAScoreModel):
 
         input_ids = [t5_tokenizer_image_token(qs, self.tokenizer, return_tensors='pt') for qs in questions]
         input_ids = torch.nn.utils.rnn.pad_sequence(
-            input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id)
+            input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id
+        )
         input_ids = input_ids[:, :self.tokenizer.model_max_length]
 
         attention_mask = input_ids.ne(self.tokenizer.pad_token_id)

evalscope/metrics/t2v_metrics/models/vqascore_models/gpt4v_model.py

@@ -1,6 +1,5 @@
 import base64
 import os
-import tiktoken
 import torch
 from openai import OpenAI
 from typing import List
@@ -42,6 +41,8 @@ class GPT4VModel(VQAScoreModel):
     def load_model(self):
         """Load the model, tokenizer, image transform
         """
+        import tiktoken
+
         self.tokenizer = tiktoken.encoding_for_model(self.model_name)
         self.client = OpenAI(api_key=self.openai_key)
         # self.candidate_answers = GPT4V_MODELS[self.model_name]['candidate_answers']
@@ -122,11 +123,13 @@ class GPT4VModel(VQAScoreModel):
             print(completion.choices[0].logprobs.content[0].top_logprobs)
             return torch.Tensor([0.0])
 
-    def forward(self,
-                images: List[str],
-                texts: List[str],
-                question_template: str = default_question_template,
-                answer_template: str = default_answer_template) -> torch.Tensor:
+    def forward(
+        self,
+        images: List[str],
+        texts: List[str],
+        question_template: str = default_question_template,
+        answer_template: str = default_answer_template
+    ) -> torch.Tensor:
         """Forward pass of the model to return n scores for n (image, text) pairs (in PyTorch Tensor)
         """
         assert len(images) == len(texts), 'Number of images and texts must match'

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/common/config.py

@@ -227,8 +227,8 @@ class ConfigValidator:
         """
         for k, v in config.items():
             assert (
-                k
-                in self.arguments), f"""{k} is not a valid argument. Support arguments are {self.format_arguments()}."""
+                k in self.arguments
+            ), f"""{k} is not a valid argument. Support arguments are {self.format_arguments()}."""
 
             if self.arguments[k].type is not None:
                 try:

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/common/gradcam.py

@@ -17,6 +17,8 @@ def getAttMap(img, attMap, blur=True, overlap=True):
     attMapV = cmap(attMap)
     attMapV = np.delete(attMapV, 3, 2)
     if overlap:
-        attMap = (1 * (1 - attMap**0.7).reshape(attMap.shape + (1, )) * img +
-                  (attMap**0.7).reshape(attMap.shape + (1, )) * attMapV)
+        attMap = (
+            1 * (1 - attMap**0.7).reshape(attMap.shape + (1, )) * img +
+            (attMap**0.7).reshape(attMap.shape + (1, )) * attMapV
+        )
     return attMap

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/common/logger.py

@@ -155,7 +155,8 @@ class MetricLogger(object):
                             time=str(iter_time),
                             data=str(data_time),
                             memory=torch.cuda.max_memory_allocated() / MB,
-                        ))
+                        )
+                    )
                 else:
                     print(
                         log_msg.format(
@@ -165,7 +166,8 @@ class MetricLogger(object):
                             meters=str(self),
                             time=str(iter_time),
                             data=str(data_time),
-                        ))
+                        )
+                    )
             i += 1
             end = time.time()
         total_time = time.time() - start_time

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/common/optims.py

@@ -13,15 +13,9 @@ from . import registry
 @registry.register_lr_scheduler('linear_warmup_step_lr')
 class LinearWarmupStepLRScheduler:
 
-    def __init__(self,
-                 optimizer,
-                 max_epoch,
-                 min_lr,
-                 init_lr,
-                 decay_rate=1,
-                 warmup_start_lr=-1,
-                 warmup_steps=0,
-                 **kwargs):
+    def __init__(
+        self, optimizer, max_epoch, min_lr, init_lr, decay_rate=1, warmup_start_lr=-1, warmup_steps=0, **kwargs
+    ):
         self.optimizer = optimizer
 
         self.max_epoch = max_epoch

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/common/registry.py

@@ -96,8 +96,9 @@ class Registry:
 
             assert issubclass(model_cls, BaseModel), 'All models must inherit BaseModel class'
             if name in cls.mapping['model_name_mapping']:
-                raise KeyError("Name '{}' already registered for {}.".format(name,
-                                                                             cls.mapping['model_name_mapping'][name]))
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(name, cls.mapping['model_name_mapping'][name])
+                )
             cls.mapping['model_name_mapping'][name] = model_cls
             return model_cls
 
@@ -120,8 +121,9 @@ class Registry:
 
             assert issubclass(processor_cls, BaseProcessor), 'All processors must inherit BaseProcessor class'
             if name in cls.mapping['processor_name_mapping']:
-                raise KeyError("Name '{}' already registered for {}.".format(
-                    name, cls.mapping['processor_name_mapping'][name]))
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(name, cls.mapping['processor_name_mapping'][name])
+                )
             cls.mapping['processor_name_mapping'][name] = processor_cls
             return processor_cls
 
@@ -141,8 +143,9 @@ class Registry:
 
         def wrap(lr_sched_cls):
             if name in cls.mapping['lr_scheduler_name_mapping']:
-                raise KeyError("Name '{}' already registered for {}.".format(
-                    name, cls.mapping['lr_scheduler_name_mapping'][name]))
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(name, cls.mapping['lr_scheduler_name_mapping'][name])
+                )
             cls.mapping['lr_scheduler_name_mapping'][name] = lr_sched_cls
             return lr_sched_cls
 
@@ -162,8 +165,9 @@ class Registry:
 
         def wrap(runner_cls):
             if name in cls.mapping['runner_name_mapping']:
-                raise KeyError("Name '{}' already registered for {}.".format(name,
-                                                                             cls.mapping['runner_name_mapping'][name]))
+                raise KeyError(
+                    "Name '{}' already registered for {}.".format(name, cls.mapping['runner_name_mapping'][name])
+                )
             cls.mapping['runner_name_mapping'][name] = runner_cls
             return runner_cls
 
@@ -285,8 +289,10 @@ class Registry:
                 break
 
         if ('writer' in cls.mapping['state'] and value == default and no_warning is False):
-            cls.mapping['state']['writer'].warning('Key {} is not present in registry, returning default value '
-                                                   'of {}'.format(original_name, default))
+            cls.mapping['state']['writer'].warning(
+                'Key {} is not present in registry, returning default value '
+                'of {}'.format(original_name, default)
+            )
         return value
 
     @classmethod

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/common/vqa_tools/vqa.py

@@ -178,8 +178,9 @@ class VQA:
         for ann in anns:
             quesId = ann['question_id']
             if res.dataset['task_type'] == 'Multiple Choice':
-                assert (ann['answer']
-                        in self.qqa[quesId]['multiple_choices']), 'predicted answer is not one of the multiple choices'
+                assert (
+                    ann['answer'] in self.qqa[quesId]['multiple_choices']
+                ), 'predicted answer is not one of the multiple choices'
             qaAnn = self.qa[quesId]
             ann['image_id'] = qaAnn['image_id']
             ann['question_type'] = qaAnn['question_type']

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/common/vqa_tools/vqa_eval.py

@@ -10,6 +10,7 @@
 __author__ = 'aagrawal'
 
 import re
+
 # This code is based on the code written by Tsung-Yi Lin for MSCOCO Python API available at the following link:
 # (https://github.com/tylin/coco-caption/blob/master/pycocoevalcap/eval.py).
 import sys
@@ -312,7 +313,8 @@ class VQAEval:
             progress = 1
             status = 'Done...\r\n'
         block = int(round(barLength * progress))
-        text = '\rFinshed Percent: [{0}] {1}% {2}'.format('#' * block + '-' * (barLength - block), int(progress * 100),
-                                                          status)
+        text = '\rFinshed Percent: [{0}] {1}% {2}'.format(
+            '#' * block + '-' * (barLength - block), int(progress * 100), status
+        )
         sys.stdout.write(text)
         sys.stdout.flush()

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/models/__init__.py

@@ -166,10 +166,12 @@ def load_model_and_preprocess(name, model_type, is_eval=False, device='cpu'):
         vis_processors, txt_processors = load_preprocess(preprocess_cfg)
     else:
         vis_processors, txt_processors = None, None
-        logging.info(f"""No default preprocess for model {name} ({model_type}).
+        logging.info(
+            f"""No default preprocess for model {name} ({model_type}).
                 This can happen if the model is not finetuned on downstream datasets,
                 or it is not intended for direct use without finetuning.
-            """)
+            """
+        )
 
     if device == 'cpu' or device == torch.device('cpu'):
         model = model.float()
@@ -195,8 +197,10 @@ class ModelZoo:
         }
 
     def __str__(self) -> str:
-        return ('=' * 50 + '\n' + f"{'Architectures':<30} {'Types'}\n" + '=' * 50 + '\n'
-                + '\n'.join([f"{name:<30} {', '.join(types)}" for name, types in self.model_zoo.items()]))
+        return (
+            '=' * 50 + '\n' + f"{'Architectures':<30} {'Types'}\n" + '=' * 50 + '\n'
+            + '\n'.join([f"{name:<30} {', '.join(types)}" for name, types in self.model_zoo.items()])
+        )
 
     def __iter__(self):
         return iter(self.model_zoo.items())

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/models/blip2_models/Qformer.py

@@ -19,13 +19,23 @@ from torch import Tensor, device, dtype, nn
 from torch.nn import CrossEntropyLoss
 from transformers.activations import ACT2FN
 from transformers.file_utils import ModelOutput
-from transformers.modeling_outputs import (BaseModelOutputWithPastAndCrossAttentions,
-                                           BaseModelOutputWithPoolingAndCrossAttentions,
-                                           CausalLMOutputWithCrossAttentions, MaskedLMOutput, MultipleChoiceModelOutput,
-                                           NextSentencePredictorOutput, QuestionAnsweringModelOutput,
-                                           SequenceClassifierOutput, TokenClassifierOutput)
-from transformers.modeling_utils import (PreTrainedModel, apply_chunking_to_forward, find_pruneable_heads_and_indices,
-                                         prune_linear_layer)
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPastAndCrossAttentions,
+    BaseModelOutputWithPoolingAndCrossAttentions,
+    CausalLMOutputWithCrossAttentions,
+    MaskedLMOutput,
+    MultipleChoiceModelOutput,
+    NextSentencePredictorOutput,
+    QuestionAnsweringModelOutput,
+    SequenceClassifierOutput,
+    TokenClassifierOutput,
+)
+from transformers.modeling_utils import (
+    PreTrainedModel,
+    apply_chunking_to_forward,
+    find_pruneable_heads_and_indices,
+    prune_linear_layer,
+)
 from transformers.models.bert.configuration_bert import BertConfig
 from transformers.utils import logging
 from typing import Any, Dict, Optional, Tuple
@@ -89,8 +99,10 @@ class BertSelfAttention(nn.Module):
         super().__init__()
         self.config = config
         if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, 'embedding_size'):
-            raise ValueError('The hidden size (%d) is not a multiple of the number of attention '
-                             'heads (%d)' % (config.hidden_size, config.num_attention_heads))
+            raise ValueError(
+                'The hidden size (%d) is not a multiple of the number of attention '
+                'heads (%d)' % (config.hidden_size, config.num_attention_heads)
+            )
 
         self.num_attention_heads = config.num_attention_heads
         self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
@@ -366,8 +378,9 @@ class BertLayer(nn.Module):
             query_attention_output = attention_output[:, :query_length, :]
 
             if self.has_cross_attention:
-                assert (encoder_hidden_states
-                        is not None), 'encoder_hidden_states must be given for cross-attention layers'
+                assert (
+                    encoder_hidden_states is not None
+                ), 'encoder_hidden_states must be given for cross-attention layers'
                 cross_attention_outputs = self.crossattention(
                     query_attention_output,
                     attention_mask,
@@ -377,8 +390,9 @@ class BertLayer(nn.Module):
                     output_attentions=output_attentions,
                 )
                 query_attention_output = cross_attention_outputs[0]
-                outputs = (outputs + cross_attention_outputs[1:-1]
-                           )  # add cross attentions if we output attention weights
+                outputs = (
+                    outputs + cross_attention_outputs[1:-1]
+                )  # add cross attentions if we output attention weights
 
             layer_output = apply_chunking_to_forward(
                 self.feed_forward_chunk_query,
@@ -457,7 +471,8 @@ class BertEncoder(nn.Module):
 
                 if use_cache:
                     logger.warn(
-                        '`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...')
+                        '`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...'
+                    )
                     use_cache = False
 
                 def create_custom_forward(module):
@@ -498,13 +513,15 @@ class BertEncoder(nn.Module):
             all_hidden_states = all_hidden_states + (hidden_states, )
 
         if not return_dict:
-            return tuple(v for v in [
-                hidden_states,
-                next_decoder_cache,
-                all_hidden_states,
-                all_self_attentions,
-                all_cross_attentions,
-            ] if v is not None)
+            return tuple(
+                v for v in [
+                    hidden_states,
+                    next_decoder_cache,
+                    all_hidden_states,
+                    all_self_attentions,
+                    all_cross_attentions,
+                ] if v is not None
+            )
         return BaseModelOutputWithPastAndCrossAttentions(
             last_hidden_state=hidden_states,
             past_key_values=next_decoder_cache,
@@ -708,8 +725,11 @@ class BertModel(BertPreTrainedModel):
             else:
                 extended_attention_mask = attention_mask[:, None, None, :]
         else:
-            raise ValueError('Wrong shape for input_ids (shape {}) or attention_mask (shape {})'.format(
-                input_shape, attention_mask.shape))
+            raise ValueError(
+                'Wrong shape for input_ids (shape {}) or attention_mask (shape {})'.format(
+                    input_shape, attention_mask.shape
+                )
+            )
 
         # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
         # masked positions, this operation will create a tensor which is 0.0 for
@@ -756,7 +776,8 @@ class BertModel(BertPreTrainedModel):
         """
         output_attentions = (output_attentions if output_attentions is not None else self.config.output_attentions)
         output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states)
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
         return_dict = (return_dict if return_dict is not None else self.config.use_return_dict)
 
         # use_cache = use_cache if use_cache is not None else self.config.use_cache
@@ -766,7 +787,8 @@ class BertModel(BertPreTrainedModel):
 
         # past_key_values_length
         past_key_values_length = (
-            past_key_values[0][0].shape[2] - self.config.query_length if past_key_values is not None else 0)
+            past_key_values[0][0].shape[2] - self.config.query_length if past_key_values is not None else 0
+        )
 
         query_length = query_embeds.shape[1] if query_embeds is not None else 0
 

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/models/blip2_models/blip2_qformer.py

@@ -54,16 +54,18 @@ class Blip2Qformer(Blip2Base):
 
         self.tokenizer = self.init_tokenizer()
 
-        self.visual_encoder, self.ln_vision = self.init_vision_encoder(vit_model, img_size, drop_path_rate,
-                                                                       use_grad_checkpoint, vit_precision)
+        self.visual_encoder, self.ln_vision = self.init_vision_encoder(
+            vit_model, img_size, drop_path_rate, use_grad_checkpoint, vit_precision
+        )
         if freeze_vit:
             for name, param in self.visual_encoder.named_parameters():
                 param.requires_grad = False
             self.visual_encoder = self.visual_encoder.eval()
             self.visual_encoder.train = disabled_train
             logging.info('freeze vision encoder')
-        self.Qformer, self.query_tokens = self.init_Qformer(num_query_token, self.visual_encoder.num_features,
-                                                            cross_attention_freq)
+        self.Qformer, self.query_tokens = self.init_Qformer(
+            num_query_token, self.visual_encoder.num_features, cross_attention_freq
+        )
         self.Qformer.resize_token_embeddings(len(self.tokenizer))
         state_dict = self.Qformer.state_dict()
         for name, param in self.Qformer.named_parameters():
@@ -135,8 +137,10 @@ class Blip2Qformer(Blip2Base):
         bs = image.size(0)
         targets = torch.linspace(rank * bs, rank * bs + bs - 1, bs, dtype=int).to(image.device)
 
-        loss_itc = (F.cross_entropy(sim_i2t, targets, label_smoothing=0.1)
-                    + F.cross_entropy(sim_t2i, targets, label_smoothing=0.1)) / 2
+        loss_itc = (
+            F.cross_entropy(sim_i2t, targets, label_smoothing=0.1)
+            + F.cross_entropy(sim_t2i, targets, label_smoothing=0.1)
+        ) / 2
 
         ###============== Image-text Matching ===================###
         text_input_ids_world = concat_all_gather(text_tokens.input_ids)
@@ -274,7 +278,8 @@ class Blip2Qformer(Blip2Base):
             top_p=top_p,
             eos_token_id=self.tokenizer.sep_token_id,
             pad_token_id=self.tokenizer.pad_token_id,
-            **model_kwargs)
+            **model_kwargs
+        )
         captions = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
         return captions
 

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/models/blip2_models/blip2_t5.py

@@ -66,8 +66,9 @@ class Blip2T5(Blip2Base):
 
         self.tokenizer = self.init_tokenizer()
 
-        self.visual_encoder, self.ln_vision = self.init_vision_encoder(vit_model, img_size, drop_path_rate,
-                                                                       use_grad_checkpoint, vit_precision)
+        self.visual_encoder, self.ln_vision = self.init_vision_encoder(
+            vit_model, img_size, drop_path_rate, use_grad_checkpoint, vit_precision
+        )
         if freeze_vit:
             for name, param in self.visual_encoder.named_parameters():
                 param.requires_grad = False
@@ -136,8 +137,9 @@ class Blip2T5(Blip2Base):
 
             encoder_atts = torch.cat([atts_t5, input_tokens.attention_mask], dim=1)
 
-            targets = output_tokens.input_ids.masked_fill(output_tokens.input_ids == self.t5_tokenizer.pad_token_id,
-                                                          -100)
+            targets = output_tokens.input_ids.masked_fill(
+                output_tokens.input_ids == self.t5_tokenizer.pad_token_id, -100
+            )
 
             inputs_embeds = self.t5_model.encoder.embed_tokens(input_tokens.input_ids)
             inputs_embeds = torch.cat([inputs_t5, inputs_embeds], dim=1)
@@ -234,17 +236,19 @@ class Blip2T5(Blip2Base):
 
         return output_text
 
-    def predict_answers(self,
-                        samples,
-                        num_beams=5,
-                        inference_method='generate',
-                        max_len=10,
-                        min_len=1,
-                        num_ans_candidates=128,
-                        answer_list=None,
-                        prompt='',
-                        length_penalty=-1,
-                        **kwargs):
+    def predict_answers(
+        self,
+        samples,
+        num_beams=5,
+        inference_method='generate',
+        max_len=10,
+        min_len=1,
+        num_ans_candidates=128,
+        answer_list=None,
+        prompt='',
+        length_penalty=-1,
+        **kwargs
+    ):
         image = samples['image']
         with self.maybe_autocast():
             image_embeds = self.ln_vision(self.visual_encoder(image))
@@ -318,13 +322,15 @@ class Blip2T5(Blip2Base):
 
                 self._lemmatizer = spacy.load('en_core_web_sm')
             except ImportError:
-                logging.error("""
+                logging.error(
+                    """
                     Please install spacy and en_core_web_sm model to apply lemmatization.
                     python -m spacy download en_core_web_sm
                     OR
                     import spacy.cli
                     spacy.cli.download("en_core_web_sm")
-                    """)
+                    """
+                )
                 exit(1)
 
         return self._lemmatizer