class_docstr: FrozenInTime model
  Args:
      img_size (int):
        the image or video height
      patch_size (int):
          patch height (equal to width)
      in_chans (int):
          number of image channel
      num_frames (int):
          maximum number of frames expected as input
      is_pretrained (bool):
          if true, then load the frozen pretrained model
      weights_path (str):
          the frozen pretrained model path, if is_pretrained is true, and this not None, then load from this path,
          otherwise, will load the frozen model from an url.
  
      projection_dim (int):
          the output dim
      video_pretrained_model (str):
          default is "vit_base_16x224", if is_pretrained is false, then must load the pretrained vit parameters
      video_is_load_pretrained (bool):
          if true, then will load vit pretrained weight
  
      text_pretrained_model (str):
          default is "distilbert-base-uncased", the pretrained model for text encoder
      text_is_load_pretrained (bool):
          if false, then will not load pretrained model for text encoder
      projection (str):
          a layer
code: def __init__(
      self,
      img_size: int = 224,
      patch_size: int = 16,
      in_chans: int = 3,
      num_frames: int = 4,
      is_pretrained: bool = False,
      weights_path: str = "",
      projection_dim: int = 256,
      video_pretrained_model: str = "vit_base_16x224",
      video_is_load_pretrained: bool = False,
      text_pretrained_model: str = "distilbert-base-uncased",
      text_is_load_pretrained: bool = False,
      projection: str = "minimal",
      device: str = "cpu",
      pretrained_url: str = "",
  ):
      super().__init__()
  
      self.text_pretrained_model = text_pretrained_model
      self.num_frames = num_frames
  
      if text_is_load_pretrained:
          # load text pretrained model
          self.text_model = AutoModel.from_pretrained(
              self.text_pretrained_model
          )
      else:
          self.config = AutoConfig.from_pretrained(
              self.text_pretrained_model
          )
          self.config.output_hidden_states = True
          self.text_model = AutoModel.from_config(config=self.config)
  
      self.text_model.train()
  
      # load video pretrained model
      model = VideoBridgeFormer(
          img_size=img_size,
          patch_size=patch_size,
          in_chans=in_chans,
          num_frames=num_frames,
      )
  
      model.head = nn.Identity()
      model.pre_logits = nn.Identity()
      ftr_dim = model.embed_dim
      # if not load pretrained model of frozen in time, then must load pretrained vit model to initial
      if (not is_pretrained) and video_is_load_pretrained:
          if video_pretrained_model == "vit_base_16x224":
              vit_model = vit.create_model(
                  model_name=video_pretrained_model, pretrained=True
              )
          else:
              raise NotImplementedError
          vit_checkpoint = vit_model.state_dict()
          model.load_state_dict(vit_checkpoint, strict=False)
      self.video_model = model
      self.video_model.fc = nn.Identity()
      # Project to a common embedding
      if projection == "minimal":
          txt_proj = nn.Sequential(
              nn.ReLU(),
              nn.Linear(
                  self.text_model.config.hidden_size, projection_dim
              ),
          )
  
          vid_proj = nn.Sequential(nn.Linear(ftr_dim, projection_dim))
          bridge_proj = nn.Sequential(
              nn.Linear(ftr_dim, projection_dim)
          )
  
      self.text_proj = txt_proj
  
      self.vid_proj = vid_proj
      self.bridge_proj = bridge_proj
      if is_pretrained:
          if weights_path not in ["", None]:
              checkpoint = torch.load(weights_path, map_location=device)
              state_dict = checkpoint["state_dict"]
          else:
              checkpoint = model_zoo.load_url(
                  pretrained_url, map_location=torch.device(device)
              )
              state_dict = checkpoint["state_dict"]
  
          new_state_dict = state_dict_data_parallel_fix(
              state_dict, self.state_dict()
          )
          new_state_dict = self._inflate_positional_embeds(
              new_state_dict
          )
          self.load_state_dict(new_state_dict, strict=True)
  
file_path: towhee/towhee/models/bridgeformer/bridge_former_training.py
imports: import torch
  from torch import nn
  import torch.nn.functional
  from torch.utils import model_zoo
  from transformers import AutoModel, AutoConfig
  from towhee.models.bridgeformer.bridge_former_training_block import VideoBridgeFormer
  from towhee.models import vit
  from towhee.models.frozen_in_time.frozen_utils import state_dict_data_parallel_fix
  import logging
label_desc: Use image node_id 1 to create a new BridgeFormerTraining object from inherited base classes: nn with example: obj = BridgeFormerTraining(img_size, patch_size, in_chans, num_frames, is_pretrained, weights_path, projection_dim, video_pretrained_model, video_is_load_pretrained, text_pretrained_model, text_is_load_pretrained, projection, device, pretrained_url)