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

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

@@ -111,7 +111,8 @@ class BlipVQA(BlipBase):
 
         image_embeds = self.visual_encoder.forward_features(samples['image'])
         encoder_output = self.text_encoder.forward_automask(
-            tokenized_text=samples['tokenized_text'], visual_embeds=image_embeds)
+            tokenized_text=samples['tokenized_text'], visual_embeds=image_embeds
+        )
 
         return encoder_output, image_embeds
 
@@ -150,15 +151,17 @@ class BlipVQA(BlipBase):
 
         return loss, answer_output, answer_targets
 
-    def predict_answers(self,
-                        samples,
-                        num_beams=3,
-                        inference_method='rank',
-                        max_len=10,
-                        min_len=1,
-                        num_ans_candidates=128,
-                        answer_list=None,
-                        **kwargs):
+    def predict_answers(
+        self,
+        samples,
+        num_beams=3,
+        inference_method='rank',
+        max_len=10,
+        min_len=1,
+        num_ans_candidates=128,
+        answer_list=None,
+        **kwargs
+    ):
         """
         Args:
             samples (dict): A dictionary containing the following keys:
@@ -204,8 +207,8 @@ class BlipVQA(BlipBase):
         if isinstance(samples['text_input'], str):
             samples['text_input'] = [samples['text_input']]
 
-        assert len(samples['text_input']) == samples['image'].size(
-            0), 'The number of questions must be equal to the batch size.'
+        assert len(samples['text_input']
+                   ) == samples['image'].size(0), 'The number of questions must be equal to the batch size.'
 
         if inference_method == 'generate':
             return self._generate_answers(samples, num_beams=num_beams, max_length=max_len, min_length=min_len)
@@ -239,7 +242,8 @@ class BlipVQA(BlipBase):
             num_beams=num_beams,
             eos_token_id=self.tokenizer.sep_token_id,
             pad_token_id=self.tokenizer.pad_token_id,
-            **model_kwargs)
+            **model_kwargs
+        )
 
         # collect answers
         answers = []

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

@@ -10,10 +10,16 @@ import torch
 import torch.utils.checkpoint
 from torch import Tensor, device, nn
 from transformers.activations import ACT2FN
-from transformers.modeling_outputs import (BaseModelOutputWithPastAndCrossAttentions,
-                                           BaseModelOutputWithPoolingAndCrossAttentions)
-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,
+)
+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 Tuple
@@ -76,8 +82,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)
@@ -465,7 +473,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):
@@ -506,13 +515,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,
@@ -703,8 +714,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
@@ -753,7 +767,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)
 
         if is_decoder:
@@ -786,8 +801,9 @@ class BertModel(BertPreTrainedModel):
 
         # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
         # ourselves in which case we just need to make it broadcastable to all heads.
-        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape, device,
-                                                                                 is_decoder)
+        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(
+            attention_mask, input_shape, device, is_decoder
+        )
 
         # If a 2D or 3D attention mask is provided for the cross-attention
         # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]

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

@@ -39,7 +39,8 @@ class Bottleneck(nn.Module):
             self.downsample = nn.Sequential(
                 OrderedDict([('-1', nn.AvgPool2d(stride)),
                              ('0', nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)),
-                             ('1', nn.BatchNorm2d(planes * self.expansion))]))
+                             ('1', nn.BatchNorm2d(planes * self.expansion))])
+            )
 
     def forward(self, x: torch.Tensor):
         identity = x
@@ -91,7 +92,8 @@ class AttentionPool2d(nn.Module):
             out_proj_bias=self.c_proj.bias,
             use_separate_proj_weight=True,
             training=self.training,
-            need_weights=False)
+            need_weights=False
+        )
 
         return x[0]
 
@@ -120,7 +122,8 @@ class ResidualAttentionBlock(nn.Module):
         self.ln_1 = LayerNorm(d_model)
         self.mlp = nn.Sequential(
             OrderedDict([('c_fc', nn.Linear(d_model, d_model * 4)), ('gelu', QuickGELU()),
-                         ('c_proj', nn.Linear(d_model * 4, d_model))]))
+                         ('c_proj', nn.Linear(d_model * 4, d_model))])
+        )
         self.ln_2 = LayerNorm(d_model)
         self.attn_mask = attn_mask
 
@@ -141,18 +144,16 @@ class ResidualAttentionBlock(nn.Module):
 
 class Transformer(nn.Module):
 
-    def __init__(self,
-                 width: int,
-                 layers: int,
-                 heads: int,
-                 attn_mask: torch.Tensor = None,
-                 use_grad_checkpointing=False):
+    def __init__(
+        self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None, use_grad_checkpointing=False
+    ):
         super().__init__()
         self.width = width
         self.layers = layers
         self.resblocks = nn.Sequential(
             *
-            [ResidualAttentionBlock(width, heads, attn_mask, use_grad_checkpointing and i > 12) for i in range(layers)])
+            [ResidualAttentionBlock(width, heads, attn_mask, use_grad_checkpointing and i > 12) for i in range(layers)]
+        )
 
     def forward(self, x: torch.Tensor):
         return self.resblocks(x)
@@ -160,8 +161,9 @@ class Transformer(nn.Module):
 
 class VisionTransformer(nn.Module):
 
-    def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int,
-                 use_grad_checkpointing: bool):
+    def __init__(
+        self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, use_grad_checkpointing: bool
+    ):
         super().__init__()
         self.input_resolution = input_resolution
         self.num_features = width

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

@@ -72,15 +72,17 @@ class Mlp(nn.Module):
 
 class Attention(nn.Module):
 
-    def __init__(self,
-                 dim,
-                 num_heads=8,
-                 qkv_bias=False,
-                 qk_scale=None,
-                 attn_drop=0.,
-                 proj_drop=0.,
-                 window_size=None,
-                 attn_head_dim=None):
+    def __init__(
+        self,
+        dim,
+        num_heads=8,
+        qkv_bias=False,
+        qk_scale=None,
+        attn_drop=0.,
+        proj_drop=0.,
+        window_size=None,
+        attn_head_dim=None
+    ):
         super().__init__()
         self.num_heads = num_heads
         head_dim = dim // num_heads
@@ -100,8 +102,9 @@ class Attention(nn.Module):
         if window_size:
             self.window_size = window_size
             self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3
-            self.relative_position_bias_table = nn.Parameter(torch.zeros(self.num_relative_distance,
-                                                                         num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+            self.relative_position_bias_table = nn.Parameter(
+                torch.zeros(self.num_relative_distance, num_heads)
+            )  # 2*Wh-1 * 2*Ww-1, nH
             # cls to token & token 2 cls & cls to cls
 
             # get pair-wise relative position index for each token inside the window
@@ -166,20 +169,22 @@ class Attention(nn.Module):
 
 class Block(nn.Module):
 
-    def __init__(self,
-                 dim,
-                 num_heads,
-                 mlp_ratio=4.,
-                 qkv_bias=False,
-                 qk_scale=None,
-                 drop=0.,
-                 attn_drop=0.,
-                 drop_path=0.,
-                 init_values=None,
-                 act_layer=nn.GELU,
-                 norm_layer=nn.LayerNorm,
-                 window_size=None,
-                 attn_head_dim=None):
+    def __init__(
+        self,
+        dim,
+        num_heads,
+        mlp_ratio=4.,
+        qkv_bias=False,
+        qk_scale=None,
+        drop=0.,
+        attn_drop=0.,
+        drop_path=0.,
+        init_values=None,
+        act_layer=nn.GELU,
+        norm_layer=nn.LayerNorm,
+        window_size=None,
+        attn_head_dim=None
+    ):
         super().__init__()
         self.norm1 = norm_layer(dim)
         self.attn = Attention(
@@ -190,7 +195,8 @@ class Block(nn.Module):
             attn_drop=attn_drop,
             proj_drop=drop,
             window_size=window_size,
-            attn_head_dim=attn_head_dim)
+            attn_head_dim=attn_head_dim
+        )
         # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
         self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
         self.norm2 = norm_layer(dim)
@@ -244,8 +250,9 @@ class RelativePositionBias(nn.Module):
         super().__init__()
         self.window_size = window_size
         self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3
-        self.relative_position_bias_table = nn.Parameter(torch.zeros(self.num_relative_distance,
-                                                                     num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros(self.num_relative_distance, num_heads)
+        )  # 2*Wh-1 * 2*Ww-1, nH
         # cls to token & token 2 cls & cls to cls
 
         # get pair-wise relative position index for each token inside the window
@@ -281,28 +288,30 @@ class VisionTransformer(nn.Module):
     """ Vision Transformer with support for patch or hybrid CNN input stage
     """
 
-    def __init__(self,
-                 img_size=224,
-                 patch_size=16,
-                 in_chans=3,
-                 num_classes=1000,
-                 embed_dim=768,
-                 depth=12,
-                 num_heads=12,
-                 mlp_ratio=4.,
-                 qkv_bias=False,
-                 qk_scale=None,
-                 drop_rate=0.,
-                 attn_drop_rate=0.,
-                 drop_path_rate=0.,
-                 norm_layer=nn.LayerNorm,
-                 init_values=None,
-                 use_abs_pos_emb=True,
-                 use_rel_pos_bias=False,
-                 use_shared_rel_pos_bias=False,
-                 use_mean_pooling=True,
-                 init_scale=0.001,
-                 use_checkpoint=False):
+    def __init__(
+        self,
+        img_size=224,
+        patch_size=16,
+        in_chans=3,
+        num_classes=1000,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4.,
+        qkv_bias=False,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.,
+        norm_layer=nn.LayerNorm,
+        init_values=None,
+        use_abs_pos_emb=True,
+        use_rel_pos_bias=False,
+        use_shared_rel_pos_bias=False,
+        use_mean_pooling=True,
+        init_scale=0.001,
+        use_checkpoint=False
+    ):
         super().__init__()
         self.image_size = img_size
         self.num_classes = num_classes
@@ -338,7 +347,8 @@ class VisionTransformer(nn.Module):
                 drop_path=dpr[i],
                 norm_layer=norm_layer,
                 init_values=init_values,
-                window_size=self.patch_embed.patch_shape if use_rel_pos_bias else None) for i in range(depth)
+                window_size=self.patch_embed.patch_shape if use_rel_pos_bias else None
+            ) for i in range(depth)
         ])
         #         self.norm = nn.Identity() if use_mean_pooling else norm_layer(embed_dim)
         #         self.fc_norm = norm_layer(embed_dim) if use_mean_pooling else None
@@ -450,7 +460,8 @@ def interpolate_pos_embed(model, checkpoint_model):
             pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:]
             pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, embedding_size).permute(0, 3, 1, 2)
             pos_tokens = torch.nn.functional.interpolate(
-                pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False)
+                pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False
+            )
             pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)
             new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1)
             checkpoint_model['pos_embed'] = new_pos_embed

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

@@ -20,13 +20,23 @@ from torch.nn import CrossEntropyLoss
 from transformers import BatchEncoding, PreTrainedTokenizer
 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 Optional, Tuple
@@ -102,8 +112,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)
@@ -408,8 +420,9 @@ class BertLayer(nn.Module):
                     output_attentions=output_attentions,
                 )
                 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,
             self.chunk_size_feed_forward,
@@ -492,7 +505,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):
@@ -533,13 +547,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,
@@ -730,8 +746,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
@@ -781,7 +800,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)
 
         if is_decoder:
@@ -814,8 +834,9 @@ class BertModel(BertPreTrainedModel):
 
         # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
         # ourselves in which case we just need to make it broadcastable to all heads.
-        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape, device,
-                                                                                 is_decoder)
+        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(
+            attention_mask, input_shape, device, is_decoder
+        )
 
         # If a 2D or 3D attention mask is provided for the cross-attention
         # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
@@ -1176,18 +1197,20 @@ class XBertLMHeadDecoder(BertLMHeadModel):
         else:
             return cls(config=med_config)
 
-    def generate_from_encoder(self,
-                              tokenized_prompt,
-                              visual_embeds,
-                              sep_token_id,
-                              pad_token_id,
-                              use_nucleus_sampling=False,
-                              num_beams=3,
-                              max_length=30,
-                              min_length=10,
-                              top_p=0.9,
-                              repetition_penalty=1.0,
-                              **kwargs):
+    def generate_from_encoder(
+        self,
+        tokenized_prompt,
+        visual_embeds,
+        sep_token_id,
+        pad_token_id,
+        use_nucleus_sampling=False,
+        num_beams=3,
+        max_length=30,
+        min_length=10,
+        top_p=0.9,
+        repetition_penalty=1.0,
+        **kwargs
+    ):
 
         if not use_nucleus_sampling:
             num_beams = num_beams
@@ -1212,7 +1235,8 @@ class XBertLMHeadDecoder(BertLMHeadModel):
                 eos_token_id=sep_token_id,
                 pad_token_id=pad_token_id,
                 repetition_penalty=1.1,
-                **model_kwargs)
+                **model_kwargs
+            )
         else:
             # beam search
             outputs = self.generate(
@@ -1223,7 +1247,8 @@ class XBertLMHeadDecoder(BertLMHeadModel):
                 eos_token_id=sep_token_id,
                 pad_token_id=pad_token_id,
                 repetition_penalty=repetition_penalty,
-                **model_kwargs)
+                **model_kwargs
+            )
 
         return outputs
 

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

@@ -343,9 +343,11 @@ def _load_weights(model: VisionTransformer, checkpoint_path: str, prefix: str =
         block.norm1.weight.copy_(_n2p(w[f'{block_prefix}LayerNorm_0/scale']))
         block.norm1.bias.copy_(_n2p(w[f'{block_prefix}LayerNorm_0/bias']))
         block.attn.qkv.weight.copy_(
-            torch.cat([_n2p(w[f'{mha_prefix}{n}/kernel'], t=False).flatten(1).T for n in ('query', 'key', 'value')]))
+            torch.cat([_n2p(w[f'{mha_prefix}{n}/kernel'], t=False).flatten(1).T for n in ('query', 'key', 'value')])
+        )
         block.attn.qkv.bias.copy_(
-            torch.cat([_n2p(w[f'{mha_prefix}{n}/bias'], t=False).reshape(-1) for n in ('query', 'key', 'value')]))
+            torch.cat([_n2p(w[f'{mha_prefix}{n}/bias'], t=False).reshape(-1) for n in ('query', 'key', 'value')])
+        )
         block.attn.proj.weight.copy_(_n2p(w[f'{mha_prefix}out/kernel']).flatten(1))
         block.attn.proj.bias.copy_(_n2p(w[f'{mha_prefix}out/bias']))
         for r in range(2):
@@ -394,7 +396,8 @@ def interpolate_pos_embed(pos_embed_checkpoint, visual_encoder):
         pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:]
         pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, embedding_size).permute(0, 3, 1, 2)
         pos_tokens = torch.nn.functional.interpolate(
-            pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False)
+            pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False
+        )
         pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)
         new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1)
         print('reshape position embedding from %d to %d' % (orig_size**2, new_size**2))

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

@@ -7,8 +7,12 @@
 
 from ..common.registry import registry
 from .base_processor import BaseProcessor
-from .blip_processors import (Blip2ImageTrainProcessor, BlipCaptionProcessor, BlipImageEvalProcessor,
-                              BlipImageTrainProcessor)
+from .blip_processors import (
+    Blip2ImageTrainProcessor,
+    BlipCaptionProcessor,
+    BlipImageEvalProcessor,
+    BlipImageTrainProcessor,
+)
 
 __all__ = [
     'BaseProcessor',

evalscope/metrics/t2v_metrics/models/vqascore_models/lavis/processors/randaugment.py

@@ -107,8 +107,9 @@ def color_func(img, factor):
     #      np.eye(3) * factor
     #      + np.float32([0.114, 0.587, 0.299]).reshape(3, 1) * (1. - factor)
     #  )[np.newaxis, np.newaxis, :]
-    M = np.float32([[0.886, -0.114, -0.114], [-0.587, 0.413, -0.587], [-0.299, -0.299, 0.701]]) * factor + np.float32(
-        [[0.114], [0.587], [0.299]])
+    M = np.float32([[0.886, -0.114, -0.114], [-0.587, 0.413, -0.587], [-0.299, -0.299, 0.701]]) * factor + np.float32([[
+        0.114
+    ], [0.587], [0.299]])
     out = np.matmul(img, M).clip(0, 255).astype(np.uint8)
     return out