def __init__(self,
                 *,
                 transformer_dim: int,
                 transformer: paddle.nn.Layer,
                 num_multimask_outputs: int=3,
                 activation: Type[paddle.nn.Layer]=paddle.nn.GELU,
                 iou_head_depth: int=3,
                 iou_head_hidden_dim: int=256) -> None:
        """
        Predicts masks given an image and prompt embeddings, using a
        tranformer architecture.

        Arguments:
          transformer_dim (int): the channel dimension of the transformer
          transformer (nn.Module): the transformer used to predict masks
          num_multimask_outputs (int): the number of masks to predict
            when disambiguating masks
          activation (nn.Module): the type of activation to use when
            upscaling masks
          iou_head_depth (int): the depth of the MLP used to predict
            mask quality
          iou_head_hidden_dim (int): the hidden dimension of the MLP
            used to predict mask quality
        """
        super().__init__()
        self.transformer_dim = transformer_dim
        self.transformer = transformer
        self.num_multimask_outputs = num_multimask_outputs
        self.iou_token = paddle.nn.Embedding(1, transformer_dim)
        self.num_mask_tokens = num_multimask_outputs + 1
        self.mask_tokens = paddle.nn.Embedding(self.num_mask_tokens,
                                               transformer_dim)
        self.output_upscaling = paddle.nn.Sequential(
            paddle.nn.Conv2DTranspose(
                in_channels=transformer_dim,
                out_channels=transformer_dim // 4,
                kernel_size=2,
                stride=2),
            LayerNorm2d(transformer_dim // 4),
            activation(),
            paddle.nn.Conv2DTranspose(
                in_channels=transformer_dim // 4,
                out_channels=transformer_dim // 8,
                kernel_size=2,
                stride=2),
            activation())
        self.output_hypernetworks_mlps = paddle.nn.LayerList(sublayers=[
            MLP(transformer_dim, transformer_dim, transformer_dim // 8, 3)
            for i in range(self.num_mask_tokens)
        ])
        self.iou_prediction_head = MLP(transformer_dim, iou_head_hidden_dim,
                                       self.num_mask_tokens, iou_head_depth)

        Predicts masks given an image and prompt embeddings, using a
        tranformer architecture.

        Arguments:
          transformer_dim (int): the channel dimension of the transformer
          transformer (nn.Module): the transformer used to predict masks
          num_multimask_outputs (int): the number of masks to predict
            when disambiguating masks
          activation (nn.Module): the type of activation to use when
            upscaling masks
          iou_head_depth (int): the depth of the MLP used to predict
            mask quality
          iou_head_hidden_dim (int): the hidden dimension of the MLP
            used to predict mask quality
        
contrib/SegmentAnything/segment_anything/modeling/mask_decoder.py