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

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

@@ -61,8 +61,9 @@ class Blip2T5Instruct(Blip2Base):
 
         self.tokenizer = self.init_tokenizer(truncation_side='left')
 
-        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
@@ -171,8 +172,9 @@ class Blip2T5Instruct(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)
@@ -196,7 +198,8 @@ class Blip2T5Instruct(Blip2Base):
         this_n_fs = random.choices(
             list(range(self.num_few_shot_examples + 1)),
             weights=[1 - self.few_shot_prob]
-            + [self.few_shot_prob / self.num_few_shot_examples] * self.num_few_shot_examples)[0]
+            + [self.few_shot_prob / self.num_few_shot_examples] * self.num_few_shot_examples
+        )[0]
 
         if this_n_fs == 0:
             return None, None
@@ -263,7 +266,8 @@ class Blip2T5Instruct(Blip2Base):
             encoder_atts = encoder_atts.reshape(encoder_atts.size(0) // this_n_fs, encoder_atts.size(1) * this_n_fs)
             inputs_embeds = inputs_embeds.reshape(
                 inputs_embeds.size(0) // this_n_fs,
-                inputs_embeds.size(1) * this_n_fs, inputs_embeds.size(2))
+                inputs_embeds.size(1) * this_n_fs, inputs_embeds.size(2)
+            )
 
         return inputs_embeds, encoder_atts
 
@@ -397,17 +401,19 @@ class Blip2T5Instruct(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
+    ):
         if isinstance(samples['text_input'], str):
             samples['text_input'] = [samples['text_input']]
 
@@ -434,7 +440,8 @@ class Blip2T5Instruct(Blip2Base):
         samples['prompt'] = text_input
 
         output_text = self.generate(
-            samples, num_beams=num_beams, max_length=max_len, min_length=min_len, length_penalty=length_penalty)
+            samples, num_beams=num_beams, max_length=max_len, min_length=min_len, length_penalty=length_penalty
+        )
 
         if self._apply_lemmatizer or ('apply_lemmatizer' in samples.keys() and samples['apply_lemmatizer']):
             output_text = self._lemmatize(output_text)
@@ -530,8 +537,8 @@ class Blip2T5Instruct(Blip2Base):
         query_tokens = self.query_tokens.expand(bs, -1, -1)
         if self.qformer_text_input:
             text_Qformer = self.tokenizer(
-                prompt, padding='longest', truncation=True, max_length=self.max_txt_len,
-                return_tensors='pt').to(image.device)
+                prompt, padding='longest', truncation=True, max_length=self.max_txt_len, return_tensors='pt'
+            ).to(image.device)
             query_atts = torch.ones(query_tokens.size()[:-1], dtype=torch.long).to(image.device)
             Qformer_atts = torch.cat([query_atts, text_Qformer.attention_mask], dim=1)
 
@@ -625,7 +632,8 @@ class Blip2T5Instruct(Blip2Base):
                 this_output_tokens_atts = output_tokens.attention_mask[start_i:end_i].repeat(bs, 1)
 
                 this_targets = this_output_tokens_ids.masked_fill(
-                    this_output_tokens_ids == self.t5_tokenizer.pad_token_id, -100)
+                    this_output_tokens_ids == self.t5_tokenizer.pad_token_id, -100
+                )
 
                 outputs = self.t5_model(
                     encoder_outputs=this_encoder_outputs,
@@ -692,13 +700,15 @@ class Blip2T5Instruct(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

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

@@ -32,7 +32,8 @@ class MLP(nn.Module):
             # nn.Dropout(0.1),
             nn.Linear(64, 16),
             nn.ReLU(),
-            nn.Linear(16, 1))
+            nn.Linear(16, 1)
+        )
 
         # initial MLP param
         for name, param in self.layers.named_parameters():

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

@@ -23,12 +23,19 @@ import torch.utils.checkpoint
 from torch import nn
 from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
 from transformers.activations import ACT2FN
-from transformers.modeling_outputs import (BaseModelOutputWithPast, CausalLMOutputWithPast,
-                                           SequenceClassifierOutputWithPast)
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPast,
+    CausalLMOutputWithPast,
+    SequenceClassifierOutputWithPast,
+)
 from transformers.modeling_utils import PreTrainedModel
 from transformers.models.llama.configuration_llama import LlamaConfig
-from transformers.utils import (add_start_docstrings, add_start_docstrings_to_model_forward, logging,
-                                replace_return_docstrings)
+from transformers.utils import (
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    logging,
+    replace_return_docstrings,
+)
 from typing import List, Optional, Tuple, Union
 
 logger = logging.get_logger(__name__)
@@ -37,10 +44,9 @@ _CONFIG_FOR_DOC = 'LlamaConfig'
 
 
 # Copied from transformers.models.bart.modeling_bart._make_causal_mask
-def _make_causal_mask(input_ids_shape: torch.Size,
-                      dtype: torch.dtype,
-                      device: torch.device,
-                      past_key_values_length: int = 0):
+def _make_causal_mask(
+    input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0
+):
     """
     Make causal mask used for bi-directional self-attention.
     """
@@ -171,8 +177,10 @@ class LlamaAttention(nn.Module):
         self.max_position_embeddings = config.max_position_embeddings
 
         if (self.head_dim * self.num_heads) != self.hidden_size:
-            raise ValueError(f'hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}'
-                             f' and `num_heads`: {self.num_heads}).')
+            raise ValueError(
+                f'hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}'
+                f' and `num_heads`: {self.num_heads}).'
+            )
         self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
         self.k_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
         self.v_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
@@ -214,13 +222,16 @@ class LlamaAttention(nn.Module):
         attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)
 
         if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):
-            raise ValueError(f'Attention weights should be of size {(bsz * self.num_heads, q_len, kv_seq_len)}, but is'
-                             f' {attn_weights.size()}')
+            raise ValueError(
+                f'Attention weights should be of size {(bsz * self.num_heads, q_len, kv_seq_len)}, but is'
+                f' {attn_weights.size()}'
+            )
 
         if attention_mask is not None:
             if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):
                 raise ValueError(
-                    f'Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}')
+                    f'Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}'
+                )
             attn_weights = attn_weights + attention_mask
             attn_weights = torch.max(attn_weights, torch.tensor(torch.finfo(attn_weights.dtype).min))
 
@@ -229,8 +240,10 @@ class LlamaAttention(nn.Module):
         attn_output = torch.matmul(attn_weights, value_states)
 
         if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):
-            raise ValueError(f'`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is'
-                             f' {attn_output.size()}')
+            raise ValueError(
+                f'`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is'
+                f' {attn_output.size()}'
+            )
 
         attn_output = attn_output.transpose(1, 2)
         attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
@@ -466,10 +479,11 @@ class LlamaModel(LlamaPreTrainedModel):
 
         if attention_mask is not None:
             # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
-            expanded_attn_mask = _expand_mask(
-                attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(inputs_embeds.device)
+            expanded_attn_mask = _expand_mask(attention_mask, inputs_embeds.dtype,
+                                              tgt_len=input_shape[-1]).to(inputs_embeds.device)
             combined_attention_mask = (
-                expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask)
+                expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask
+            )
 
         return combined_attention_mask
 
@@ -488,7 +502,8 @@ class LlamaModel(LlamaPreTrainedModel):
     ) -> Union[Tuple, BaseModelOutputWithPast]:
         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
+        )
         use_cache = use_cache if use_cache is not None else self.config.use_cache
 
         return_dict = return_dict if return_dict is not None else self.config.use_return_dict
@@ -513,7 +528,8 @@ class LlamaModel(LlamaPreTrainedModel):
         if position_ids is None:
             device = input_ids.device if input_ids is not None else inputs_embeds.device
             position_ids = torch.arange(
-                past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device)
+                past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device
+            )
             position_ids = position_ids.unsqueeze(0).view(-1, seq_length)
         else:
             position_ids = position_ids.view(-1, seq_length).long()
@@ -525,15 +541,17 @@ class LlamaModel(LlamaPreTrainedModel):
             attention_mask = torch.ones((batch_size, seq_length_with_past),
                                         dtype=torch.bool,
                                         device=inputs_embeds.device)
-        attention_mask = self._prepare_decoder_attention_mask(attention_mask, (batch_size, seq_length), inputs_embeds,
-                                                              past_key_values_length)
+        attention_mask = self._prepare_decoder_attention_mask(
+            attention_mask, (batch_size, seq_length), inputs_embeds, past_key_values_length
+        )
 
         hidden_states = inputs_embeds
 
         if self.gradient_checkpointing and self.training:
             if use_cache:
                 logger.warning_once(
-                    '`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
 
         # decoder layers
@@ -672,7 +690,8 @@ class LlamaForCausalLM(LlamaPreTrainedModel):
 
         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
 
         # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
@@ -719,12 +738,9 @@ class LlamaForCausalLM(LlamaPreTrainedModel):
             attentions=outputs.attentions,
         )
 
-    def prepare_inputs_for_generation(self,
-                                      input_ids,
-                                      past_key_values=None,
-                                      attention_mask=None,
-                                      inputs_embeds=None,
-                                      **kwargs):
+    def prepare_inputs_for_generation(
+        self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
+    ):
         if past_key_values:
             input_ids = input_ids[:, -1:]
 

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

@@ -22,13 +22,24 @@ from torch import nn
 from torch.nn import CrossEntropyLoss
 from torch.utils.checkpoint import checkpoint
 from transformers.activations import ACT2FN
-from transformers.modeling_outputs import (BaseModelOutput, BaseModelOutputWithPastAndCrossAttentions, Seq2SeqLMOutput,
-                                           Seq2SeqModelOutput)
+from transformers.modeling_outputs import (
+    BaseModelOutput,
+    BaseModelOutputWithPastAndCrossAttentions,
+    Seq2SeqLMOutput,
+    Seq2SeqModelOutput,
+)
 from transformers.modeling_utils import PreTrainedModel
 from transformers.models.t5.configuration_t5 import T5Config
 from transformers.pytorch_utils import ALL_LAYERNORM_LAYERS, find_pruneable_heads_and_indices, prune_linear_layer
-from transformers.utils import (DUMMY_INPUTS, DUMMY_MASK, add_start_docstrings, add_start_docstrings_to_model_forward,
-                                is_torch_fx_proxy, logging, replace_return_docstrings)
+from transformers.utils import (
+    DUMMY_INPUTS,
+    DUMMY_MASK,
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    is_torch_fx_proxy,
+    logging,
+    replace_return_docstrings,
+)
 from transformers.utils.model_parallel_utils import assert_device_map, get_device_map
 from typing import Optional, Tuple, Union
 
@@ -63,8 +74,10 @@ def load_tf_weights_in_t5(model, config, tf_checkpoint_path):
         import re
         import tensorflow as tf
     except ImportError:
-        logger.error('Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see '
-                     'https://www.tensorflow.org/install/ for installation instructions.')
+        logger.error(
+            'Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see '
+            'https://www.tensorflow.org/install/ for installation instructions.'
+        )
         raise
     tf_path = os.path.abspath(tf_checkpoint_path)
     logger.info(f'Converting TensorFlow checkpoint from {tf_path}')
@@ -82,13 +95,15 @@ def load_tf_weights_in_t5(model, config, tf_checkpoint_path):
         name = txt_name.split('/')
         # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v
         # which are not required for using pretrained model
-        if any(n in [
+        if any(
+            n in [
                 'adam_v',
                 'adam_m',
                 'AdamWeightDecayOptimizer',
                 'AdamWeightDecayOptimizer_1',
                 'global_step',
-        ] for n in name):
+            ] for n in name
+        ):
             logger.info(f"Skipping {'/'.join(name)}")
             tf_weights.pop(txt_name, None)
             continue
@@ -149,7 +164,8 @@ def load_tf_weights_in_t5(model, config, tf_checkpoint_path):
             array = np.transpose(array)
         try:
             assert (
-                pointer.shape == array.shape), f'Pointer shape {pointer.shape} and array shape {array.shape} mismatched'
+                pointer.shape == array.shape
+            ), f'Pointer shape {pointer.shape} and array shape {array.shape} mismatched'
         except AssertionError as e:
             e.args += (pointer.shape, array.shape)
             raise
@@ -392,9 +408,10 @@ class T5Attention(nn.Module):
         is_small = relative_position < max_exact
 
         # The other half of the buckets are for logarithmically bigger bins in positions up to max_distance
-        relative_position_if_large = max_exact + (torch.log(relative_position.float() / max_exact)
-                                                  / math.log(max_distance / max_exact) *
-                                                  (num_buckets - max_exact)).to(torch.long)
+        relative_position_if_large = max_exact + (
+            torch.log(relative_position.float() / max_exact) / math.log(max_distance / max_exact) *
+            (num_buckets - max_exact)
+        ).to(torch.long)
         relative_position_if_large = torch.min(
             relative_position_if_large,
             torch.full_like(relative_position_if_large, num_buckets - 1),
@@ -497,8 +514,9 @@ class T5Attention(nn.Module):
         )
 
         # compute scores
-        scores = torch.matmul(query_states, key_states.transpose(
-            3, 2))  # equivalent of torch.einsum("bnqd,bnkd->bnqk", query_states, key_states), compatible with onnx op>9
+        scores = torch.matmul(
+            query_states, key_states.transpose(3, 2)
+        )  # equivalent of torch.einsum("bnqd,bnkd->bnqk", query_states, key_states), compatible with onnx op>9
 
         if position_bias is None:
             if not self.has_relative_attention_bias:
@@ -528,10 +546,11 @@ class T5Attention(nn.Module):
             position_bias_masked = position_bias
 
         scores += position_bias_masked
-        attn_weights = nn.functional.softmax(
-            scores.float(), dim=-1).type_as(scores)  # (batch_size, n_heads, seq_length, key_length)
+        attn_weights = nn.functional.softmax(scores.float(),
+                                             dim=-1).type_as(scores)  # (batch_size, n_heads, seq_length, key_length)
         attn_weights = nn.functional.dropout(
-            attn_weights, p=self.dropout, training=self.training)  # (batch_size, n_heads, seq_length, key_length)
+            attn_weights, p=self.dropout, training=self.training
+        )  # (batch_size, n_heads, seq_length, key_length)
 
         # Mask heads if we want to
         if layer_head_mask is not None:
@@ -655,7 +674,8 @@ class T5Block(nn.Module):
                 raise ValueError(
                     f'There should be {expected_num_past_key_values} past states. '
                     f"{'2 (past / key) for cross attention. ' if expected_num_past_key_values == 4 else ''}"
-                    f'Got {len(past_key_value)} past key / value states')
+                    f'Got {len(past_key_value)} past key / value states'
+                )
 
             self_attn_past_key_value = past_key_value[:2]
             cross_attn_past_key_value = past_key_value[2:]
@@ -809,7 +829,8 @@ class T5PreTrainedModel(PreTrainedModel):
 
         assert decoder_start_token_id is not None, (
             'self.model.config.decoder_start_token_id has to be defined. In T5 it is usually set to the pad_token_id.'
-            ' See T5 docs for more information')
+            ' See T5 docs for more information'
+        )
 
         # shift inputs to the right
         if is_torch_fx_proxy(input_ids):
@@ -836,8 +857,9 @@ class T5Stack(T5PreTrainedModel):
         self.embed_tokens = embed_tokens
         self.is_decoder = config.is_decoder
 
-        self.block = nn.ModuleList(
-            [T5Block(config, has_relative_attention_bias=bool(i == 0)) for i in range(config.num_layers)])
+        self.block = nn.ModuleList([
+            T5Block(config, has_relative_attention_bias=bool(i == 0)) for i in range(config.num_layers)
+        ])
         self.final_layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
         self.dropout = nn.Dropout(config.dropout_rate)
 
@@ -852,7 +874,8 @@ class T5Stack(T5PreTrainedModel):
     def parallelize(self, device_map=None):
         # Check validity of device_map
         self.device_map = (
-            get_device_map(len(self.block), range(torch.cuda.device_count())) if device_map is None else device_map)
+            get_device_map(len(self.block), range(torch.cuda.device_count())) if device_map is None else device_map
+        )
         assert_device_map(self.device_map, len(self.block))
         self.model_parallel = True
         self.first_device = ('cpu' if 'cpu' in self.device_map.keys() else 'cuda:' + str(min(self.device_map.keys())))
@@ -908,13 +931,15 @@ class T5Stack(T5PreTrainedModel):
         use_cache = use_cache if use_cache is not None else self.config.use_cache
         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 input_ids is not None and inputs_embeds is not None:
             err_msg_prefix = 'decoder_' if self.is_decoder else ''
             raise ValueError(
-                f'You cannot specify both {err_msg_prefix}input_ids and {err_msg_prefix}inputs_embeds at the same time')
+                f'You cannot specify both {err_msg_prefix}input_ids and {err_msg_prefix}inputs_embeds at the same time'
+            )
         elif input_ids is not None:
             input_shape = input_ids.size()
             input_ids = input_ids.view(-1, input_shape[-1])
@@ -1009,7 +1034,8 @@ class T5Stack(T5PreTrainedModel):
             if self.gradient_checkpointing and self.training:
                 if use_cache:
                     logger.warning(
-                        '`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):
@@ -1082,13 +1108,15 @@ class T5Stack(T5PreTrainedModel):
             all_hidden_states = all_hidden_states + (hidden_states, )
 
         if not return_dict:
-            return tuple(v for v in [
-                hidden_states,
-                present_key_value_states,
-                all_hidden_states,
-                all_attentions,
-                all_cross_attentions,
-            ] if v is not None)
+            return tuple(
+                v for v in [
+                    hidden_states,
+                    present_key_value_states,
+                    all_hidden_states,
+                    all_attentions,
+                    all_cross_attentions,
+                ] if v is not None
+            )
         return BaseModelOutputWithPastAndCrossAttentions(
             last_hidden_state=hidden_states,
             past_key_values=present_key_value_states,
@@ -1298,7 +1326,8 @@ class T5Model(T5PreTrainedModel):
     def parallelize(self, device_map=None):
         self.device_map = (
             get_device_map(len(self.encoder.block), range(torch.cuda.device_count()))
-            if device_map is None else device_map)
+            if device_map is None else device_map
+        )
         assert_device_map(self.device_map, len(self.encoder.block))
         self.encoder.parallelize(self.device_map)
         self.decoder.parallelize(self.device_map)
@@ -1493,7 +1522,8 @@ class T5ForConditionalGeneration(T5PreTrainedModel):
     def parallelize(self, device_map=None):
         self.device_map = (
             get_device_map(len(self.encoder.block), range(torch.cuda.device_count()))
-            if device_map is None else device_map)
+            if device_map is None else device_map
+        )
         assert_device_map(self.device_map, len(self.encoder.block))
         self.encoder.parallelize(self.device_map)
         self.decoder.parallelize(self.device_map)
@@ -1731,8 +1761,9 @@ class T5ForConditionalGeneration(T5PreTrainedModel):
             reordered_layer_past_states = ()
             for layer_past_state in layer_past_states:
                 # need to set correct `past` for each of the four key / value states
-                reordered_layer_past_states = reordered_layer_past_states + (layer_past_state.index_select(
-                    0, beam_idx.to(layer_past_state.device)), )
+                reordered_layer_past_states = reordered_layer_past_states + (
+                    layer_past_state.index_select(0, beam_idx.to(layer_past_state.device)),
+                )
 
             assert reordered_layer_past_states[0].shape == layer_past_states[0].shape
             assert len(reordered_layer_past_states) == len(layer_past_states)
@@ -1770,7 +1801,8 @@ class T5EncoderModel(T5PreTrainedModel):
     def parallelize(self, device_map=None):
         self.device_map = (
             get_device_map(len(self.encoder.block), range(torch.cuda.device_count()))
-            if device_map is None else device_map)
+            if device_map is None else device_map
+        )
         assert_device_map(self.device_map, len(self.encoder.block))
         self.encoder.parallelize(self.device_map)
         self.model_parallel = True

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

@@ -26,7 +26,8 @@ def tie_encoder_decoder_weights(encoder: nn.Module, decoder: nn.Module, base_mod
         depth=0,
     ):
         assert isinstance(decoder_pointer, nn.Module) and isinstance(
-            encoder_pointer, nn.Module), f'{decoder_pointer} and {encoder_pointer} have to be of type torch.nn.Module'
+            encoder_pointer, nn.Module
+        ), f'{decoder_pointer} and {encoder_pointer} have to be of type torch.nn.Module'
         if hasattr(decoder_pointer, 'weight') and skip_key not in module_name:
             assert hasattr(encoder_pointer, 'weight')
             encoder_pointer.weight = decoder_pointer.weight
@@ -39,8 +40,9 @@ def tie_encoder_decoder_weights(encoder: nn.Module, decoder: nn.Module, base_mod
         encoder_modules = encoder_pointer._modules
         decoder_modules = decoder_pointer._modules
         if len(decoder_modules) > 0:
-            assert (len(encoder_modules) >
-                    0), f'Encoder module {encoder_pointer} does not match decoder module {decoder_pointer}'
+            assert (
+                len(encoder_modules) > 0
+            ), f'Encoder module {encoder_pointer} does not match decoder module {decoder_pointer}'
 
             all_encoder_weights = set([module_name + '/' + sub_name for sub_name in encoder_modules.keys()])
             encoder_layer_pos = 0
@@ -49,8 +51,8 @@ def tie_encoder_decoder_weights(encoder: nn.Module, decoder: nn.Module, base_mod
                     encoder_name = str(int(name) + encoder_layer_pos)
                     decoder_name = name
                     if not isinstance(
-                            decoder_modules[decoder_name],
-                            type(encoder_modules[encoder_name]),
+                        decoder_modules[decoder_name],
+                        type(encoder_modules[encoder_name]),
                     ) and len(encoder_modules) != len(decoder_modules):
                         # this can happen if the name corresponds to the position in a list module list of layers
                         # in this case the decoder has added a cross-attention that the encoder does not have

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/models/blip_models/blip.py

@@ -37,11 +37,13 @@ class BlipBase(BaseModel):
 
         state_dict = checkpoint['model']
 
-        state_dict['visual_encoder.pos_embed'] = interpolate_pos_embed(state_dict['visual_encoder.pos_embed'],
-                                                                       self.visual_encoder)
+        state_dict['visual_encoder.pos_embed'] = interpolate_pos_embed(
+            state_dict['visual_encoder.pos_embed'], self.visual_encoder
+        )
         if 'visual_encoder_m.pos_embed' in self.state_dict().keys():
-            state_dict['visual_encoder_m.pos_embed'] = interpolate_pos_embed(state_dict['visual_encoder_m.pos_embed'],
-                                                                             self.visual_encoder_m)
+            state_dict['visual_encoder_m.pos_embed'] = interpolate_pos_embed(
+                state_dict['visual_encoder_m.pos_embed'], self.visual_encoder_m
+            )
 
         for key in self.state_dict().keys():
             if key in state_dict.keys():

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/models/blip_models/blip_image_text_matching.py

@@ -119,7 +119,8 @@ class BlipITM(BlipBase):
         elif match_head == 'itc':
             encoder_input_ids[:, 0] = self.tokenizer.cls_token_id
             text_output = self.text_encoder(
-                encoder_input_ids, attention_mask=text_attention_mask, return_dict=True, mode='text')
+                encoder_input_ids, attention_mask=text_attention_mask, return_dict=True, mode='text'
+            )
             image_feat = F.normalize(self.vision_proj(image_embeds[:, 0, :]), dim=-1)
             text_feat = F.normalize(self.text_proj(text_output.last_hidden_state[:, 0, :]), dim=-1)
 
@@ -155,13 +156,14 @@ def compute_gradcam(model, visual_input, text_input, tokenized_text, block_num=6
     model.zero_grad()
     loss.backward()
     with torch.no_grad():
-        mask = tokenized_text.attention_mask.view(tokenized_text.attention_mask.size(0), 1, -1, 1,
-                                                  1)  # (bsz,1,token_len, 1,1)
+        mask = tokenized_text.attention_mask.view(
+            tokenized_text.attention_mask.size(0), 1, -1, 1, 1
+        )  # (bsz,1,token_len, 1,1)
         token_length = tokenized_text.attention_mask.sum(dim=-1) - 2
         token_length = token_length.cpu()
         # grads and cams [bsz, num_head, seq_len, image_patch]
-        grads = model.text_encoder.base_model.base_model.encoder.layer[
-            block_num].crossattention.self.get_attn_gradients()
+        grads = model.text_encoder.base_model.base_model.encoder.layer[block_num
+                                                                       ].crossattention.self.get_attn_gradients()
         cams = model.text_encoder.base_model.base_model.encoder.layer[block_num].crossattention.self.get_attention_map()
 
         # assume using vit with 576 num image patch

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/models/blip_models/blip_nlvr.py

@@ -157,8 +157,9 @@ class BlipNLVR(BlipBase, MomentumDistilationMixin):
             raise RuntimeError('checkpoint url or path is invalid')
         state_dict = checkpoint['model']
 
-        state_dict['visual_encoder.pos_embed'] = interpolate_pos_embed(state_dict['visual_encoder.pos_embed'],
-                                                                       self.visual_encoder)
+        state_dict['visual_encoder.pos_embed'] = interpolate_pos_embed(
+            state_dict['visual_encoder.pos_embed'], self.visual_encoder
+        )
 
         for key in list(state_dict.keys()):
             if 'crossattention.self.' in key:

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/models/blip_models/blip_outputs.py

@@ -7,8 +7,11 @@
 
 import torch
 from dataclasses import dataclass
-from transformers.modeling_outputs import (BaseModelOutputWithPoolingAndCrossAttentions,
-                                           CausalLMOutputWithCrossAttentions, ModelOutput)
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPoolingAndCrossAttentions,
+    CausalLMOutputWithCrossAttentions,
+    ModelOutput,
+)
 from typing import Optional