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 _inflate_positional_embeds(self, new_state_dict):
      # allow loading of timesformer with fewer num_frames
      curr_keys = list(self.state_dict().keys())
      if (
          "video_model.temporal_embed" in new_state_dict
          and "video_model.temporal_embed" in curr_keys
      ):
          load_temporal_embed = new_state_dict[
              "video_model.temporal_embed"
          ]
          load_num_frames = load_temporal_embed.shape[1]
          curr_num_frames = self.num_frames
          embed_dim = load_temporal_embed.shape[2]
  
          if load_num_frames != curr_num_frames:
              if load_num_frames > curr_num_frames:
                  logging.info(
                      "### loaded %s model has MORE frames than current... "
                      "### loading weights, filling in the extras via %s",
                      self.video_model_type,
                      self.load_temporal_fix,
                  )
                  new_temporal_embed = load_temporal_embed[
                      :, :curr_num_frames, :
                  ]
              else:
                  logging.info(
                      "### loaded %s model has FEWER frames than current..."
                      "### loading weights, filling in the extras via %s",
                      self.video_model_type,
                      self.load_temporal_fix,
                  )
                  if self.load_temporal_fix == "zeros":
                      new_temporal_embed = torch.zeros(
                          [
                              load_temporal_embed.shape[0],
                              curr_num_frames,
                              embed_dim,
                          ]
                      )
                      new_temporal_embed[
                          :, :load_num_frames
                      ] = load_temporal_embed
                  elif self.load_temporal_fix in ["interp", "bilinear"]:
                      # interpolate
                      # unsqueeze so pytorch thinks its an image
                      mode = "nearest"
                      if self.load_temporal_fix == "bilinear":
                          mode = "bilinear"
                      load_temporal_embed = (
                          load_temporal_embed.unsqueeze(0)
                      )
                      new_temporal_embed = F.interpolate(
                          load_temporal_embed,
                          (curr_num_frames, embed_dim),
                          mode=mode,
                      ).squeeze(0)
                  else:
                      raise NotImplementedError
              new_state_dict[
                  "video_model.temporal_embed"
              ] = new_temporal_embed
      # allow loading with smaller spatial patches. assumes custom border crop, to append the
      # border patches to the input sequence
      if (
          "video_model.pos_embed" in new_state_dict
          and "video_model.pos_embed" in curr_keys
      ):
          load_pos_embed = new_state_dict["video_model.pos_embed"]
          load_num_patches = load_pos_embed.shape[1]
          curr_pos_embed = self.state_dict()["video_model.pos_embed"]
          if load_num_patches != curr_pos_embed.shape[1]:
              raise NotImplementedError(
                  "Loading models with different spatial resolution / patch number not yet implemented, sorry."
              )
  
      return new_state_dict
  
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 5 for calling the BridgeFormerTraining obj's underlying member method code with example usage: obj._inflate_positional_embeds(new_state_dict) and returns: new_state_dict