code: def initialize_vision_modules(
      self,
      model_args,
      fsdp=None,
      add_region_feature=False,
      region_geo_sampler=False,
      sampler_pooler_mode="mean",
  ):
      vision_tower = model_args.vision_tower
      mm_vision_select_layer = model_args.mm_vision_select_layer
      mm_vision_select_feature = model_args.mm_vision_select_feature
      pretrain_mm_mlp_adapter = model_args.pretrain_mm_mlp_adapter
  
      self.config.mm_vision_tower = vision_tower
  
      vision_tower = build_vision_tower(model_args)
  
      if fsdp is not None and len(fsdp) > 0:
          self.vision_tower = [vision_tower]
      else:
          self.vision_tower = vision_tower
  
      self.config.use_mm_proj = True
      self.config.mm_hidden_size = vision_tower.hidden_size
      self.config.mm_vision_select_layer = mm_vision_select_layer
      self.config.mm_vision_select_feature = mm_vision_select_feature
  
      if not hasattr(self, "mm_projector"):
          self.mm_projector = nn.Linear(
              self.config.mm_hidden_size, self.config.hidden_size
          )
  
      if add_region_feature:
          if region_geo_sampler:
              self.config.region_geo_sampler = True
              self.config.sampler_pooler_mode = sampler_pooler_mode
              # pdb.set_trace()
              if not hasattr(self, "region_geo_sampler"):
                  self.region_geo_sampler = GeoRegionSampler(
                      input_dim=self.config.mm_hidden_size,
                      output_dim=self.config.hidden_size,
                      num_init_point=self.max_sample_point,
                      num_sub_point=[128, 32],
                      num_neighbor=[24, 24],
                      pooler_mode=sampler_pooler_mode,
                  )
          else:
              self.config.region_fea_adapter = True
              if not hasattr(self, "region_fea_adapter"):
                  self.region_fea_adapter = nn.Linear(
                      self.config.mm_hidden_size,
                      self.config.hidden_size,
                  )
  
      if pretrain_mm_mlp_adapter is not None:
          mm_projector_weights = torch.load(
              pretrain_mm_mlp_adapter, map_location="cpu"
          )
  
          def get_w(weights, keyword):
              return {
                  k.split(keyword + ".")[1]: v
                  for k, v in weights.items()
                  if keyword in k
              }
  
          self.mm_projector.load_state_dict(
              get_w(mm_projector_weights, "mm_projector")
          )
  
imports: from abc import ABC, abstractmethod
  import torch
  import torch.nn
  import torch.nn.functional
  import math
  from .multimodal_encoder.builder import build_vision_tower
  import pdb
  from ferret.constants import IGNORE_INDEX, IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_PATCH_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
label_desc: Use image node_id 3 for calling the FERRETMetaModel obj's underlying member method code with example usage: obj.initialize_vision_modules(model_args, fsdp, add_region_feature, region_geo_sampler, sampler_pooler_mode) and returns: unknown