//  [python]
def off_forward(self, input):
        """
        Args:
            inputs: input images.

        Returns:
            Tuple[Tensor]: FPN feature.
        """

        #  backbone
        rurrent_out_features = self.backbone(torch.split(input, 3, dim=1)[0])
        rurrent_features = [rurrent_out_features[f] for f in self.in_features]
        [rurrent_x2, rurrent_x1, rurrent_x0] = rurrent_features

        rurrent_fpn_out0 = self.lateral_conv0(rurrent_x0)  # 1024->512/32
        rurrent_f_out0 = t.upsample(
            rurrent_fpn_out0, size=rurrent_x1.shape[2:4],
            mode='nearest')  # 512/16
        rurrent_f_out0 = torch.cat([rurrent_f_out0, rurrent_x1],
                                   1)  # 512->1024/16
        rurrent_f_out0 = self.C3_p4(rurrent_f_out0)  # 1024->512/16

        rurrent_fpn_out1 = self.reduce_conv1(rurrent_f_out0)  # 512->256/16
        rurrent_f_out1 = t.upsample(
            rurrent_fpn_out1, size=rurrent_x2.shape[2:4],
            mode='nearest')  # 256/8
        rurrent_f_out1 = torch.cat([rurrent_f_out1, rurrent_x2],
                                   1)  # 256->512/8
        rurrent_pan_out2 = self.C3_p3(rurrent_f_out1)  # 512->256/8

        rurrent_p_out1 = self.bu_conv2(rurrent_pan_out2)  # 256->256/16
        rurrent_p_out1 = torch.cat([rurrent_p_out1, rurrent_fpn_out1],
                                   1)  # 256->512/16
        rurrent_pan_out1 = self.C3_n3(rurrent_p_out1)  # 512->512/16

        rurrent_p_out0 = self.bu_conv1(rurrent_pan_out1)  # 512->512/32
        rurrent_p_out0 = torch.cat([rurrent_p_out0, rurrent_fpn_out0],
                                   1)  # 512->1024/32
        rurrent_pan_out0 = self.C3_n4(rurrent_p_out0)  # 1024->1024/32

        #####

        support_out_features = self.backbone(torch.split(input, 3, dim=1)[1])
        support_features = [support_out_features[f] for f in self.in_features]
        [support_x2, support_x1, support_x0] = support_features

        support_fpn_out0 = self.lateral_conv0(support_x0)  # 1024->512/32
        support_f_out0 = t.upsample(
            support_fpn_out0, size=support_x1.shape[2:4],
            mode='nearest')  # 512/16
        support_f_out0 = torch.cat([support_f_out0, support_x1],
                                   1)  # 512->1024/16
        support_f_out0 = self.C3_p4(support_f_out0)  # 1024->512/16

        support_fpn_out1 = self.reduce_conv1(support_f_out0)  # 512->256/16
        support_f_out1 = t.upsample(
            support_fpn_out1, size=support_x2.shape[2:4],
            mode='nearest')  # 256/8
        support_f_out1 = torch.cat([support_f_out1, support_x2],
                                   1)  # 256->512/8
        support_pan_out2 = self.C3_p3(support_f_out1)  # 512->256/8

        support_p_out1 = self.bu_conv2(support_pan_out2)  # 256->256/16
        support_p_out1 = torch.cat([support_p_out1, support_fpn_out1],
                                   1)  # 256->512/16
        support_pan_out1 = self.C3_n3(support_p_out1)  # 512->512/16

        support_p_out0 = self.bu_conv1(support_pan_out1)  # 512->512/32
        support_p_out0 = torch.cat([support_p_out0, support_fpn_out0],
                                   1)  # 512->1024/32
        support_pan_out0 = self.C3_n4(support_p_out0)  # 1024->1024/32

        # 0.5 channel
        pan_out2 = torch.cat(
            [self.jian2(rurrent_pan_out2),
             self.jian2(support_pan_out2)],
            dim=1) + rurrent_pan_out2
        pan_out1 = torch.cat(
            [self.jian1(rurrent_pan_out1),
             self.jian1(support_pan_out1)],
            dim=1) + rurrent_pan_out1
        pan_out0 = torch.cat(
            [self.jian0(rurrent_pan_out0),
             self.jian0(support_pan_out0)],
            dim=1) + rurrent_pan_out0

        outputs = (pan_out2, pan_out1, pan_out0)

        return outputs