| import torch.nn as nn
|
| import torch
|
| from .head import VQAHead_cls,VARHead,VQAHead
|
| from .backbone.blip import MyBLIP as BLIP
|
|
|
| class VideoTextAlignmentModel(nn.Module):
|
| def __init__(
|
| self,
|
| backbone_size="divided",
|
| backbone_preserve_keys="fragments,resize",
|
| multi=False,
|
| layer=-1,
|
| backbone=dict(
|
| resize={"window_size": (4, 4, 4)}, fragments={"window_size": (4, 4, 4)}
|
| ),
|
| divide_head=False,
|
| head_type='VQAhead_cls',
|
| vqa_head=dict(in_channels=768),
|
| var=False,
|
| use_tn=False,
|
| model_path=None,
|
| ):
|
| self.backbone_preserve_keys = backbone_preserve_keys.split(",")
|
| self.multi = multi
|
| self.layer = layer
|
| super().__init__()
|
|
|
| for key, hypers in backbone.items():
|
| if key not in self.backbone_preserve_keys:
|
| continue
|
| if backbone_size == "divided":
|
| t_backbone_size = hypers["type"]
|
| else:
|
| t_backbone_size = backbone_size
|
|
|
| assert t_backbone_size == "blip"
|
| type = hypers["blip_type"]
|
| b = BLIP(type, model_path)
|
|
|
| setattr(self, key + "_backbone", b)
|
| if divide_head:
|
| for key in backbone:
|
| pre_pool = False
|
| if key not in self.backbone_preserve_keys:
|
| continue
|
| in_channel = 768
|
| b = VQAHead_cls(pre_pool=pre_pool, in_channels=in_channel, **vqa_head)
|
| setattr(self, key + "_head", b)
|
| else:
|
| if var:
|
| self.vqa_head = VARHead(**vqa_head)
|
| else:
|
| self.vqa_head = VQAHead(**vqa_head)
|
|
|
| def forward(
|
| self,
|
| vclips,
|
| prompts=None,
|
| inference=True,
|
| return_pooled_feats=False,
|
| return_raw_feats=False,
|
| reduce_scores=False,
|
| pooled=False,
|
| **kwargs
|
| ):
|
|
|
| assert (return_pooled_feats & return_raw_feats) == False, "Please only choose one kind of features to return"
|
| if inference:
|
| self.eval()
|
| with torch.no_grad():
|
| scores = []
|
| feats = {}
|
| for key in self.backbone_preserve_keys:
|
| feat = getattr(self, key.split("_")[0] + "_backbone")(
|
| vclips[key], prompts
|
| )
|
| if hasattr(self, key.split("_")[0] + "_head"):
|
| scores += [getattr(self, key.split("_")[0] + "_head")(feat)[0]]
|
| else:
|
| scores += [getattr(self, "vqa_head")(feat)]
|
| if return_pooled_feats:
|
| feats[key] = feat
|
| if return_raw_feats:
|
| feats[key] = feat
|
| if reduce_scores:
|
| if len(scores) > 1:
|
| scores = reduce(lambda x, y: x + y, scores)
|
| else:
|
| scores = scores[0]
|
| if pooled:
|
| scores = torch.mean(scores, (1, 2, 3, 4))
|
| self.train()
|
| if return_pooled_feats or return_raw_feats:
|
| return scores, feats
|
| return scores
|
| else:
|
| self.train()
|
| scores = []
|
| feats = {}
|
|
|
| for key in vclips:
|
| feat = getattr(self, key.split("_")[0] + "_backbone")(
|
| vclips[key], prompts
|
| )
|
| if hasattr(self, key.split("_")[0] + "_head"):
|
| scores += [getattr(self, key.split("_")[0] + "_head")(feat)[0]]
|
| else:
|
| scores += [getattr(self, "vqa_head")(feat)]
|
| if return_pooled_feats:
|
| feats[key] = feat.mean((-3, -2, -1))
|
| if reduce_scores:
|
| if len(scores) > 1:
|
| scores = reduce(lambda x, y: x + y, scores)
|
| else:
|
| scores = scores[0]
|
| if pooled:
|
|
|
| scores = torch.mean(scores, (1, 2, 3, 4))
|
|
|
|
|
| if return_pooled_feats:
|
| return scores, feats
|
| return scores
|
|
|
