fix order of classes

custom_modeling_albert_flax.py

@@ -32,146 +32,118 @@ from transformers.modeling_flax_utils import (
     overwrite_call_docstring,
 )
 
-class CustomFlaxAlbertForMaskedLM(FlaxAlbertPreTrainedModel):
-    module_class = CustomFlaxAlbertForMaskedLMModule
-
-class CustomFlaxAlbertForMaskedLMModule(nn.Module):
+class CustomFlaxAlbertSelfAttention(nn.Module):
     config: AlbertConfig
-    dtype: jnp.dtype = jnp.float32
+    dtype: jnp.dtype = jnp.float32  # the dtype of the computation
 
     def setup(self):
-        self.albert = CustomFlaxAlbertModule(config=self.config, add_pooling_layer=False, dtype=self.dtype)
-        self.predictions = FlaxAlbertOnlyMLMHead(config=self.config, dtype=self.dtype)
+        if self.config.hidden_size % self.config.num_attention_heads != 0:
+            raise ValueError(
+                "`config.hidden_size`: {self.config.hidden_size} has to be a multiple of `config.num_attention_heads` "
+                "                   : {self.config.num_attention_heads}"
+            )
+
+        self.query = nn.Dense(
+            self.config.hidden_size,
+            dtype=self.dtype,
+            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
+        )
+        self.key = nn.Dense(
+            self.config.hidden_size,
+            dtype=self.dtype,
+            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
+        )
+        self.value = nn.Dense(
+            self.config.hidden_size,
+            dtype=self.dtype,
+            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
+        )
+        self.dense = nn.Dense(
+            self.config.hidden_size,
+            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
+            dtype=self.dtype,
+        )
+        self.LayerNorm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
+        self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
 
     def __call__(
         self,
-        input_ids,
+        hidden_states,
         attention_mask,
-        token_type_ids,
-        position_ids,
-        deterministic: bool = True,
+        deterministic=True,
         output_attentions: bool = False,
-        output_hidden_states: bool = False,
-        return_dict: bool = True,
+        layer_id: int = None,
         interv_type: str = "swap",
         interv_dict: dict = {},
     ):
-        # Model
-        outputs = self.albert(
-            input_ids,
-            attention_mask,
-            token_type_ids,
-            position_ids,
-            deterministic=deterministic,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            interv_type=interv_type,
-            interv_dict=interv_dict,
-        )
-
-        hidden_states = outputs[0]
-        if self.config.tie_word_embeddings:
-            shared_embedding = self.albert.variables["params"]["embeddings"]["word_embeddings"]["embedding"]
-        else:
-            shared_embedding = None
-
-        # Compute the prediction scores
-        logits = self.predictions(hidden_states, shared_embedding=shared_embedding)
-
-        if not return_dict:
-            return (logits,) + outputs[1:]
+        head_dim = self.config.hidden_size // self.config.num_attention_heads
 
-        return FlaxMaskedLMOutput(
-            logits=logits,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
+        query_states = self.query(hidden_states).reshape(
+            hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
+        )
+        value_states = self.value(hidden_states).reshape(
+            hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
+        )
+        key_states = self.key(hidden_states).reshape(
+            hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
         )
 
-class CustomFlaxAlbertModule(nn.Module):
-    config: AlbertConfig
-    dtype: jnp.dtype = jnp.float32  # the dtype of the computation
-    add_pooling_layer: bool = True
-
-    def setup(self):
-        self.embeddings = FlaxAlbertEmbeddings(self.config, dtype=self.dtype)
-        self.encoder = CustomFlaxAlbertEncoder(self.config, dtype=self.dtype)
-        if self.add_pooling_layer:
-            self.pooler = nn.Dense(
-                self.config.hidden_size,
-                kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
-                dtype=self.dtype,
-                name="pooler",
+        # Convert the boolean attention mask to an attention bias.
+        if attention_mask is not None:
+            # attention mask in the form of attention bias
+            attention_mask = jnp.expand_dims(attention_mask, axis=(-3, -2))
+            attention_bias = lax.select(
+                attention_mask > 0,
+                jnp.full(attention_mask.shape, 0.0).astype(self.dtype),
+                jnp.full(attention_mask.shape, jnp.finfo(self.dtype).min).astype(self.dtype),
             )
-            self.pooler_activation = nn.tanh
         else:
-            self.pooler = None
-            self.pooler_activation = None
-
-    def __call__(
-        self,
-        input_ids,
-        attention_mask,
-        token_type_ids: Optional[np.ndarray] = None,
-        position_ids: Optional[np.ndarray] = None,
-        deterministic: bool = True,
-        output_attentions: bool = False,
-        output_hidden_states: bool = False,
-        return_dict: bool = True,
-        interv_type: str = "swap",
-        interv_dict: dict = {},
-    ):
-        # make sure `token_type_ids` is correctly initialized when not passed
-        if token_type_ids is None:
-            token_type_ids = jnp.zeros_like(input_ids)
-
-        # make sure `position_ids` is correctly initialized when not passed
-        if position_ids is None:
-            position_ids = jnp.broadcast_to(jnp.arange(jnp.atleast_2d(input_ids).shape[-1]), input_ids.shape)
+            attention_bias = None
 
-        hidden_states = self.embeddings(input_ids, token_type_ids, position_ids, deterministic=deterministic)
+        dropout_rng = None
+        if not deterministic and self.config.attention_probs_dropout_prob > 0.0:
+            dropout_rng = self.make_rng("dropout")
 
-        outputs = self.encoder(
-            hidden_states,
-            attention_mask,
+        attn_weights = dot_product_attention_weights(
+            query_states,
+            key_states,
+            bias=attention_bias,
+            dropout_rng=dropout_rng,
+            dropout_rate=self.config.attention_probs_dropout_prob,
+            broadcast_dropout=True,
             deterministic=deterministic,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            interv_type=interv_type,
-            interv_dict=interv_dict,
+            dtype=self.dtype,
+            precision=None,
         )
-        hidden_states = outputs[0]
-        if self.add_pooling_layer:
-            pooled = self.pooler(hidden_states[:, 0])
-            pooled = self.pooler_activation(pooled)
-        else:
-            pooled = None
 
-        if not return_dict:
-            # if pooled is None, don't return it
-            if pooled is None:
-                return (hidden_states,) + outputs[1:]
-            return (hidden_states, pooled) + outputs[1:]
+        attn_output = jnp.einsum("...hqk,...khd->...qhd", attn_weights, value_states)
+        attn_output = attn_output.reshape(attn_output.shape[:2] + (-1,))
 
-        return FlaxBaseModelOutputWithPooling(
-            last_hidden_state=hidden_states,
-            pooler_output=pooled,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
+        projected_attn_output = self.dense(attn_output)
+        projected_attn_output = self.dropout(projected_attn_output, deterministic=deterministic)
+        layernormed_attn_output = self.LayerNorm(projected_attn_output + hidden_states)
+        outputs = (layernormed_attn_output, attn_weights) if output_attentions else (layernormed_attn_output,)
+        return outputs
 
-class CustomFlaxAlbertEncoder(nn.Module):
+class CustomFlaxAlbertLayer(nn.Module):
     config: AlbertConfig
     dtype: jnp.dtype = jnp.float32  # the dtype of the computation
 
     def setup(self):
-        self.embedding_hidden_mapping_in = nn.Dense(
+        self.attention = CustomFlaxAlbertSelfAttention(self.config, dtype=self.dtype)
+        self.ffn = nn.Dense(
+            self.config.intermediate_size,
+            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
+            dtype=self.dtype,
+        )
+        self.activation = ACT2FN[self.config.hidden_act]
+        self.ffn_output = nn.Dense(
             self.config.hidden_size,
             kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
             dtype=self.dtype,
         )
-        self.albert_layer_groups = CustomFlaxAlbertLayerGroups(self.config, dtype=self.dtype)
+        self.full_layer_layer_norm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
+        self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
 
     def __call__(
         self,
@@ -179,30 +151,39 @@ class CustomFlaxAlbertEncoder(nn.Module):
         attention_mask,
         deterministic: bool = True,
         output_attentions: bool = False,
-        output_hidden_states: bool = False,
-        return_dict: bool = True,
+        layer_id: int = None,
         interv_type: str = "swap",
         interv_dict: dict = {},
     ):
-        hidden_states = self.embedding_hidden_mapping_in(hidden_states)
-        return self.albert_layer_groups(
+        attention_outputs = self.attention(
             hidden_states,
             attention_mask,
             deterministic=deterministic,
             output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
+            layer_id=layer_id,
             interv_type=interv_type,
             interv_dict=interv_dict,
         )
+        attention_output = attention_outputs[0]
+        ffn_output = self.ffn(attention_output)
+        ffn_output = self.activation(ffn_output)
+        ffn_output = self.ffn_output(ffn_output)
+        ffn_output = self.dropout(ffn_output, deterministic=deterministic)
+        hidden_states = self.full_layer_layer_norm(ffn_output + attention_output)
 
-class CustomFlaxAlbertLayerGroups(nn.Module):
+        outputs = (hidden_states,)
+
+        if output_attentions:
+            outputs += (attention_outputs[1],)
+        return outputs
+
+class CustomFlaxAlbertLayerCollection(nn.Module):
     config: AlbertConfig
     dtype: jnp.dtype = jnp.float32  # the dtype of the computation
 
     def setup(self):
         self.layers = [
-            CustomFlaxAlbertLayerCollections(self.config, name=str(i), layer_index=str(i), dtype=self.dtype)
-            for i in range(self.config.num_hidden_groups)
+            CustomFlaxAlbertLayer(self.config, name=str(i), dtype=self.dtype) for i in range(self.config.inner_group_num)
         ]
 
     def __call__(
@@ -212,39 +193,37 @@ class CustomFlaxAlbertLayerGroups(nn.Module):
         deterministic: bool = True,
         output_attentions: bool = False,
         output_hidden_states: bool = False,
-        return_dict: bool = True,
+        layer_id: int = None,
         interv_type: str = "swap",
         interv_dict: dict = {},
     ):
-        all_attentions = () if output_attentions else None
-        all_hidden_states = (hidden_states,) if output_hidden_states else None
+        layer_hidden_states = ()
+        layer_attentions = ()
 
-        for i in range(self.config.num_hidden_layers):
-            # Index of the hidden group
-            group_idx = int(i / (self.config.num_hidden_layers / self.config.num_hidden_groups))
-            layer_group_output = self.layers[group_idx](
+        for layer_index, albert_layer in enumerate(self.layers):
+            layer_output = albert_layer(
                 hidden_states,
                 attention_mask,
                 deterministic=deterministic,
                 output_attentions=output_attentions,
-                output_hidden_states=output_hidden_states,
-                layer_id=i,
+                layer_id=layer_id,
                 interv_type=interv_type,
                 interv_dict=interv_dict,
             )
-            hidden_states = layer_group_output[0]
+            hidden_states = layer_output[0]
 
             if output_attentions:
-                all_attentions = all_attentions + layer_group_output[-1]
+                layer_attentions = layer_attentions + (layer_output[1],)
 
             if output_hidden_states:
-                all_hidden_states = all_hidden_states + (hidden_states,)
+                layer_hidden_states = layer_hidden_states + (hidden_states,)
 
-        if not return_dict:
-            return tuple(v for v in [hidden_states, all_hidden_states, all_attentions] if v is not None)
-        return FlaxBaseModelOutput(
-            last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_attentions
-        )
+        outputs = (hidden_states,)
+        if output_hidden_states:
+            outputs = outputs + (layer_hidden_states,)
+        if output_attentions:
+            outputs = outputs + (layer_attentions,)
+        return outputs  # last-layer hidden state, (layer hidden states), (layer attentions)
 
 class CustomFlaxAlbertLayerCollections(nn.Module):
     config: AlbertConfig
@@ -277,13 +256,14 @@ class CustomFlaxAlbertLayerCollections(nn.Module):
         )
         return outputs
 
-class CustomFlaxAlbertLayerCollection(nn.Module):
+class CustomFlaxAlbertLayerGroups(nn.Module):
     config: AlbertConfig
     dtype: jnp.dtype = jnp.float32  # the dtype of the computation
 
     def setup(self):
         self.layers = [
-            CustomFlaxAlbertLayer(self.config, name=str(i), dtype=self.dtype) for i in range(self.config.inner_group_num)
+            CustomFlaxAlbertLayerCollections(self.config, name=str(i), layer_index=str(i), dtype=self.dtype)
+            for i in range(self.config.num_hidden_groups)
         ]
 
     def __call__(
@@ -293,57 +273,51 @@ class CustomFlaxAlbertLayerCollection(nn.Module):
         deterministic: bool = True,
         output_attentions: bool = False,
         output_hidden_states: bool = False,
-        layer_id: int = None,
+        return_dict: bool = True,
         interv_type: str = "swap",
         interv_dict: dict = {},
     ):
-        layer_hidden_states = ()
-        layer_attentions = ()
+        all_attentions = () if output_attentions else None
+        all_hidden_states = (hidden_states,) if output_hidden_states else None
 
-        for layer_index, albert_layer in enumerate(self.layers):
-            layer_output = albert_layer(
+        for i in range(self.config.num_hidden_layers):
+            # Index of the hidden group
+            group_idx = int(i / (self.config.num_hidden_layers / self.config.num_hidden_groups))
+            layer_group_output = self.layers[group_idx](
                 hidden_states,
                 attention_mask,
                 deterministic=deterministic,
                 output_attentions=output_attentions,
-                layer_id=layer_id,
+                output_hidden_states=output_hidden_states,
+                layer_id=i,
                 interv_type=interv_type,
                 interv_dict=interv_dict,
             )
-            hidden_states = layer_output[0]
+            hidden_states = layer_group_output[0]
 
             if output_attentions:
-                layer_attentions = layer_attentions + (layer_output[1],)
+                all_attentions = all_attentions + layer_group_output[-1]
 
             if output_hidden_states:
-                layer_hidden_states = layer_hidden_states + (hidden_states,)
+                all_hidden_states = all_hidden_states + (hidden_states,)
 
-        outputs = (hidden_states,)
-        if output_hidden_states:
-            outputs = outputs + (layer_hidden_states,)
-        if output_attentions:
-            outputs = outputs + (layer_attentions,)
-        return outputs  # last-layer hidden state, (layer hidden states), (layer attentions)
+        if not return_dict:
+            return tuple(v for v in [hidden_states, all_hidden_states, all_attentions] if v is not None)
+        return FlaxBaseModelOutput(
+            last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_attentions
+        )
 
-class CustomFlaxAlbertLayer(nn.Module):
+class CustomFlaxAlbertEncoder(nn.Module):
     config: AlbertConfig
     dtype: jnp.dtype = jnp.float32  # the dtype of the computation
 
     def setup(self):
-        self.attention = CustomFlaxAlbertSelfAttention(self.config, dtype=self.dtype)
-        self.ffn = nn.Dense(
-            self.config.intermediate_size,
-            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
-            dtype=self.dtype,
-        )
-        self.activation = ACT2FN[self.config.hidden_act]
-        self.ffn_output = nn.Dense(
+        self.embedding_hidden_mapping_in = nn.Dense(
             self.config.hidden_size,
             kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
             dtype=self.dtype,
         )
-        self.full_layer_layer_norm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
-        self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
+        self.albert_layer_groups = CustomFlaxAlbertLayerGroups(self.config, dtype=self.dtype)
 
     def __call__(
         self,
@@ -351,121 +325,147 @@ class CustomFlaxAlbertLayer(nn.Module):
         attention_mask,
         deterministic: bool = True,
         output_attentions: bool = False,
-        layer_id: int = None,
+        output_hidden_states: bool = False,
+        return_dict: bool = True,
         interv_type: str = "swap",
         interv_dict: dict = {},
     ):
-        attention_outputs = self.attention(
+        hidden_states = self.embedding_hidden_mapping_in(hidden_states)
+        return self.albert_layer_groups(
             hidden_states,
             attention_mask,
             deterministic=deterministic,
             output_attentions=output_attentions,
-            layer_id=layer_id,
+            output_hidden_states=output_hidden_states,
             interv_type=interv_type,
             interv_dict=interv_dict,
         )
-        attention_output = attention_outputs[0]
-        ffn_output = self.ffn(attention_output)
-        ffn_output = self.activation(ffn_output)
-        ffn_output = self.ffn_output(ffn_output)
-        ffn_output = self.dropout(ffn_output, deterministic=deterministic)
-        hidden_states = self.full_layer_layer_norm(ffn_output + attention_output)
-
-        outputs = (hidden_states,)
-
-        if output_attentions:
-            outputs += (attention_outputs[1],)
-        return outputs
 
-class CustomFlaxAlbertSelfAttention(nn.Module):
+class CustomFlaxAlbertModule(nn.Module):
     config: AlbertConfig
     dtype: jnp.dtype = jnp.float32  # the dtype of the computation
+    add_pooling_layer: bool = True
 
     def setup(self):
-        if self.config.hidden_size % self.config.num_attention_heads != 0:
-            raise ValueError(
-                "`config.hidden_size`: {self.config.hidden_size} has to be a multiple of `config.num_attention_heads` "
-                "                   : {self.config.num_attention_heads}"
+        self.embeddings = FlaxAlbertEmbeddings(self.config, dtype=self.dtype)
+        self.encoder = CustomFlaxAlbertEncoder(self.config, dtype=self.dtype)
+        if self.add_pooling_layer:
+            self.pooler = nn.Dense(
+                self.config.hidden_size,
+                kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
+                dtype=self.dtype,
+                name="pooler",
             )
-
-        self.query = nn.Dense(
-            self.config.hidden_size,
-            dtype=self.dtype,
-            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
-        )
-        self.key = nn.Dense(
-            self.config.hidden_size,
-            dtype=self.dtype,
-            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
-        )
-        self.value = nn.Dense(
-            self.config.hidden_size,
-            dtype=self.dtype,
-            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
-        )
-        self.dense = nn.Dense(
-            self.config.hidden_size,
-            kernel_init=jax.nn.initializers.normal(self.config.initializer_range),
-            dtype=self.dtype,
-        )
-        self.LayerNorm = nn.LayerNorm(epsilon=self.config.layer_norm_eps, dtype=self.dtype)
-        self.dropout = nn.Dropout(rate=self.config.hidden_dropout_prob)
+            self.pooler_activation = nn.tanh
+        else:
+            self.pooler = None
+            self.pooler_activation = None
 
     def __call__(
         self,
-        hidden_states,
+        input_ids,
         attention_mask,
-        deterministic=True,
+        token_type_ids: Optional[np.ndarray] = None,
+        position_ids: Optional[np.ndarray] = None,
+        deterministic: bool = True,
         output_attentions: bool = False,
-        layer_id: int = None,
+        output_hidden_states: bool = False,
+        return_dict: bool = True,
         interv_type: str = "swap",
         interv_dict: dict = {},
     ):
-        head_dim = self.config.hidden_size // self.config.num_attention_heads
+        # make sure `token_type_ids` is correctly initialized when not passed
+        if token_type_ids is None:
+            token_type_ids = jnp.zeros_like(input_ids)
 
-        query_states = self.query(hidden_states).reshape(
-            hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
-        )
-        value_states = self.value(hidden_states).reshape(
-            hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
+        # make sure `position_ids` is correctly initialized when not passed
+        if position_ids is None:
+            position_ids = jnp.broadcast_to(jnp.arange(jnp.atleast_2d(input_ids).shape[-1]), input_ids.shape)
+
+        hidden_states = self.embeddings(input_ids, token_type_ids, position_ids, deterministic=deterministic)
+
+        outputs = self.encoder(
+            hidden_states,
+            attention_mask,
+            deterministic=deterministic,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            interv_type=interv_type,
+            interv_dict=interv_dict,
         )
-        key_states = self.key(hidden_states).reshape(
-            hidden_states.shape[:2] + (self.config.num_attention_heads, head_dim)
+        hidden_states = outputs[0]
+        if self.add_pooling_layer:
+            pooled = self.pooler(hidden_states[:, 0])
+            pooled = self.pooler_activation(pooled)
+        else:
+            pooled = None
+
+        if not return_dict:
+            # if pooled is None, don't return it
+            if pooled is None:
+                return (hidden_states,) + outputs[1:]
+            return (hidden_states, pooled) + outputs[1:]
+
+        return FlaxBaseModelOutputWithPooling(
+            last_hidden_state=hidden_states,
+            pooler_output=pooled,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
         )
 
-        # Convert the boolean attention mask to an attention bias.
-        if attention_mask is not None:
-            # attention mask in the form of attention bias
-            attention_mask = jnp.expand_dims(attention_mask, axis=(-3, -2))
-            attention_bias = lax.select(
-                attention_mask > 0,
-                jnp.full(attention_mask.shape, 0.0).astype(self.dtype),
-                jnp.full(attention_mask.shape, jnp.finfo(self.dtype).min).astype(self.dtype),
-            )
-        else:
-            attention_bias = None
+class CustomFlaxAlbertForMaskedLMModule(nn.Module):
+    config: AlbertConfig
+    dtype: jnp.dtype = jnp.float32
 
-        dropout_rng = None
-        if not deterministic and self.config.attention_probs_dropout_prob > 0.0:
-            dropout_rng = self.make_rng("dropout")
+    def setup(self):
+        self.albert = CustomFlaxAlbertModule(config=self.config, add_pooling_layer=False, dtype=self.dtype)
+        self.predictions = FlaxAlbertOnlyMLMHead(config=self.config, dtype=self.dtype)
 
-        attn_weights = dot_product_attention_weights(
-            query_states,
-            key_states,
-            bias=attention_bias,
-            dropout_rng=dropout_rng,
-            dropout_rate=self.config.attention_probs_dropout_prob,
-            broadcast_dropout=True,
+    def __call__(
+        self,
+        input_ids,
+        attention_mask,
+        token_type_ids,
+        position_ids,
+        deterministic: bool = True,
+        output_attentions: bool = False,
+        output_hidden_states: bool = False,
+        return_dict: bool = True,
+        interv_type: str = "swap",
+        interv_dict: dict = {},
+    ):
+        # Model
+        outputs = self.albert(
+            input_ids,
+            attention_mask,
+            token_type_ids,
+            position_ids,
             deterministic=deterministic,
-            dtype=self.dtype,
-            precision=None,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            interv_type=interv_type,
+            interv_dict=interv_dict,
         )
 
-        attn_output = jnp.einsum("...hqk,...khd->...qhd", attn_weights, value_states)
-        attn_output = attn_output.reshape(attn_output.shape[:2] + (-1,))
+        hidden_states = outputs[0]
+        if self.config.tie_word_embeddings:
+            shared_embedding = self.albert.variables["params"]["embeddings"]["word_embeddings"]["embedding"]
+        else:
+            shared_embedding = None
 
-        projected_attn_output = self.dense(attn_output)
-        projected_attn_output = self.dropout(projected_attn_output, deterministic=deterministic)
-        layernormed_attn_output = self.LayerNorm(projected_attn_output + hidden_states)
-        outputs = (layernormed_attn_output, attn_weights) if output_attentions else (layernormed_attn_output,)
-        return outputs
+        # Compute the prediction scores
+        logits = self.predictions(hidden_states, shared_embedding=shared_embedding)
+
+        if not return_dict:
+            return (logits,) + outputs[1:]
+
+        return FlaxMaskedLMOutput(
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+class CustomFlaxAlbertForMaskedLM(FlaxAlbertPreTrainedModel):
+    module_class = CustomFlaxAlbertForMaskedLMModule