class_docstr: Bottleneck for the ResNet backbone in `DetectoRS
  <https://arxiv.org/pdf/2006.02334.pdf>`_.
  
  This bottleneck allows the users to specify whether to use
  SAC (Switchable Atrous Convolution) and RFP (Recursive Feature Pyramid).
  
  Args:
       inplanes (int): The number of input channels.
       planes (int): The number of output channels before expansion.
       rfp_inplanes (int, optional): The number of channels from RFP.
           Default: None. If specified, an additional conv layer will be
           added for ``rfp_feat``. Otherwise, the structure is the same as
           base class.
       sac (dict, optional): Dictionary to construct SAC. Default: None.
       init_cfg (dict or list[dict], optional): Initialization config dict.
          Default: None
docstr: The forward function that also takes the RFP features as input.
docstr_tok: ["The","forward","function","that","also","takes","the","RFP","features","as","input","."]
code: def rfp_forward(self, x, rfp_feat):
      """The forward function that also takes the RFP features as input."""
  
      def _inner_forward(x):
          identity = x
  
          out = self.conv1(x)
          out = self.norm1(out)
          out = self.relu(out)
  
          if self.with_plugins:
              out = self.forward_plugin(
                  out, self.after_conv1_plugin_names
              )
  
          out = self.conv2(out)
          out = self.norm2(out)
          out = self.relu(out)
  
          if self.with_plugins:
              out = self.forward_plugin(
                  out, self.after_conv2_plugin_names
              )
  
          out = self.conv3(out)
          out = self.norm3(out)
  
          if self.with_plugins:
              out = self.forward_plugin(
                  out, self.after_conv3_plugin_names
              )
  
          if self.downsample is not None:
              identity = self.downsample(x)
  
          out += identity
  
          return out
  
      if self.with_cp and x.requires_grad:
          out = cp.checkpoint(_inner_forward, x)
      else:
          out = _inner_forward(x)
  
      if self.rfp_inplanes:
          rfp_feat = self.rfp_conv(rfp_feat)
          out = out + rfp_feat
  
      out = self.relu(out)
  
      return out
  
imports: import torch.nn
  import torch.utils.checkpoint
  from mmcv.cnn import build_conv_layer, build_norm_layer
  from mmengine.logging import MMLogger
  from mmengine.model import Sequential, constant_init, kaiming_init
  from mmengine.runner.checkpoint import load_checkpoint
  from torch.nn.modules.batchnorm import _BatchNorm
  from mmdet.registry import MODELS
  from .resnet import BasicBlock
  from .resnet import Bottleneck
  from .resnet import ResNet
label_desc: Use image node_id 2 for calling the Bottleneck obj's underlying member method code with example usage: obj.rfp_forward(x, rfp_feat) and returns: out, out