class_docstr: Visual-lang Fusion Module.
class_docstr_tok: ["Visual-lang","Fusion","Module","."]
docstr: Initialize layers of the model.
docstr_tok: ["Initialize","layers","of","the","model","."]
code: def _init_layers(self) -> None:
      """Initialize layers of the model."""
      bias_value = -math.log((1 - 0.01) / 0.01)
  
      dyhead_tower = []
      for i in range(self.num_dyhead_blocks):
          if self.early_fuse:
              # cross-modality fusion
              dyhead_tower.append(
                  VLFuse(use_checkpoint=self.use_checkpoint)
              )
              # lang branch
              dyhead_tower.append(
                  BertEncoderLayer(
                      self.lang_cfg,
                      clamp_min_for_underflow=True,
                      clamp_max_for_overflow=True,
                  )
              )
  
          # vision branch
          dyhead_tower.append(
              DyConv(
                  lambda i, o, s: Conv3x3Norm(
                      i,
                      o,
                      s,
                      use_dcn=self.use_dcn,
                      norm_type=["gn", 16],
                  ),
                  self.in_channels if i == 0 else self.feat_channels,
                  self.feat_channels,
                  use_dyrelu=(
                      self.use_dyrelu
                      and self.in_channels == self.feat_channels
                  )
                  if i == 0
                  else self.use_dyrelu,
                  use_dyfuse=(
                      self.use_dyfuse
                      and self.in_channels == self.feat_channels
                  )
                  if i == 0
                  else self.use_dyfuse,
                  use_dcn=(
                      self.use_dcn
                      and self.in_channels == self.feat_channels
                  )
                  if i == 0
                  else self.use_dcn,
              )
          )
  
      self.add_module("dyhead_tower", nn.Sequential(*dyhead_tower))
  
      self.bbox_pred = nn.Conv2d(
          self.feat_channels, self.num_base_priors * 4, kernel_size=1
      )
      self.centerness = nn.Conv2d(
          self.feat_channels, self.num_base_priors * 1, kernel_size=1
      )
      self.dot_product_projection_text = nn.Linear(
          self.lang_dim,
          self.num_base_priors * self.feat_channels,
          bias=True,
      )
      self.log_scale = nn.Parameter(
          torch.Tensor([0.0]), requires_grad=True
      )
      self.bias_lang = nn.Parameter(
          torch.zeros(self.lang_dim), requires_grad=True
      )
      self.bias0 = nn.Parameter(
          torch.Tensor([bias_value]), requires_grad=True
      )
      self.scales = nn.ModuleList([Scale(1.0) for _ in range(5)])
  
imports: import copy
  import math
  from typing import Callable, List, Optional, Sequence, Tuple, Union
  import torch
  import torch.nn
  import torch.nn.functional
  from mmcv.cnn import Scale
  from mmcv.ops.modulated_deform_conv import ModulatedDeformConv2d
  from mmengine.config import ConfigDict
  from mmengine.model import BaseModel
  from mmengine.structures import InstanceData
  from torch import Tensor
  from mmdet.registry import MODELS
  from mmdet.structures.bbox import cat_boxes
  from mmdet.utils import InstanceList, OptInstanceList, reduce_mean
  from ..utils import BertEncoderLayer, VLFuse, filter_scores_and_topk, permute_and_flatten, select_single_mlvl, unpack_gt_instances
  from ..utils.vlfuse_helper import MAX_CLAMP_VALUE
  from .atss_head import ATSSHead
label_desc: Use image node_id 2 for calling the VLFusionModule obj's underlying member method code with example usage: obj._init_layers() without return types