[API] Fix matmul api useage. (#4058)

Author: ZHUI

applications/document_intelligence/doc_vqa/Rerank/src/model/ernie.py

@@ -13,19 +13,15 @@
 # limitations under the License.
 """Ernie model."""
 
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-from __future__ import absolute_import
+from __future__ import absolute_import, division, print_function, unicode_literals
 
 import json
-import six
 import logging
 from io import open
 
+import paddle
 import paddle.fluid as fluid
-
+import six
 from model.transformer_encoder import encoder, pre_process_layer
 
 log = logging.getLogger(__name__)
@@ -140,7 +136,7 @@ def _build_model(self, model_name, src_ids, position_ids, sentence_ids, task_ids
 
         emb_out = pre_process_layer(emb_out, "nd", self._prepostprocess_dropout, name=model_name + "pre_encoder")
 
-        self_attn_mask = fluid.layers.matmul(x=input_mask, y=input_mask, transpose_y=True)
+        self_attn_mask = paddle.matmul(x=input_mask, y=input_mask, transpose_y=True)
 
         self_attn_mask = fluid.layers.scale(x=self_attn_mask, scale=10000.0, bias=-1.0, bias_after_scale=False)
         n_head_self_attn_mask = fluid.layers.stack(x=[self_attn_mask] * self._n_head, axis=1)
@@ -226,7 +222,7 @@ def get_lm_output(self, mask_label, mask_pos):
             name="mask_lm_out_fc.b_0", initializer=fluid.initializer.Constant(value=0.0)
         )
         if self._weight_sharing:
-            fc_out = fluid.layers.matmul(
+            fc_out = paddle.matmul(
                 x=mask_trans_feat,
                 y=fluid.default_main_program().global_block().var(self._word_emb_name),
                 transpose_y=True,

applications/document_intelligence/doc_vqa/Rerank/src/model/transformer_encoder.py

@@ -13,12 +13,11 @@
 # limitations under the License.
 """Transformer encoder."""
 
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
+from __future__ import absolute_import, division, print_function
 
 from functools import partial
 
+import paddle
 import paddle.fluid as fluid
 import paddle.fluid.layers as layers
 
@@ -111,15 +110,15 @@ def scaled_dot_product_attention(q, k, v, attn_bias, d_key, dropout_rate):
         Scaled Dot-Product Attention
         """
         scaled_q = layers.scale(x=q, scale=d_key**-0.5)
-        product = layers.matmul(x=scaled_q, y=k, transpose_y=True)
+        product = paddle.matmul(x=scaled_q, y=k, transpose_y=True)
         if attn_bias:
             product += attn_bias
         weights = layers.softmax(product)
         if dropout_rate:
             weights = layers.dropout(
                 weights, dropout_prob=dropout_rate, dropout_implementation="upscale_in_train", is_test=False
             )
-        out = layers.matmul(weights, v)
+        out = paddle.matmul(weights, v)
         return out
 
     q, k, v = __compute_qkv(queries, keys, values, n_head, d_key, d_value)

examples/language_model/gpt-3/dygraph/modeling.py

@@ -13,25 +13,25 @@
 # limitations under the License.
 
 import collections
-import math
 
-import numpy as np
 import paddle
+import paddle.incubate as incubate
 import paddle.nn as nn
 import paddle.nn.functional as F
 import paddle.tensor as tensor
+from paddle.distributed import fleet
+from paddle.distributed.fleet.meta_parallel import (
+    LayerDesc,
+    PipelineLayer,
+    SharedLayerDesc,
+    get_rng_state_tracker,
+)
+from paddle.distributed.fleet.utils import recompute
 from paddle.fluid import layers
 from paddle.nn.layer.transformer import _convert_param_attr_to_list
 
 from paddlenlp.transformers import PretrainedModel, register_base_model
 
-import paddlenlp
-from paddle.distributed import fleet
-from paddle.distributed.fleet.meta_parallel import get_rng_state_tracker
-from paddle.distributed.fleet.meta_parallel import LayerDesc, PipelineLayer, SharedLayerDesc
-import paddle.incubate as incubate
-from paddle.distributed.fleet.utils import recompute
-
 __all__ = [
     "GPTModel",
     "GPTPretrainedModel",
@@ -46,7 +46,7 @@ def parallel_matmul(lm_output, logit_weights, parallel_output):
     hcg = fleet.get_hybrid_communicate_group()
     model_parallel_group = hcg.get_model_parallel_group()
     world_size = hcg.get_model_parallel_world_size()
-    rank = hcg.get_model_parallel_rank()
+    # rank = hcg.get_model_parallel_rank()
 
     if world_size > 1:
         input_parallel = paddle.distributed.collective._c_identity(lm_output, group=model_parallel_group)
@@ -215,7 +215,7 @@ def forward(self, query, key, value, attn_mask=None, use_cache=False, cache=None
         else:
             q, k, v, cache = self._prepare_qkv(query, key, value, use_cache, cache)
         # scale dot product attention
-        product = layers.matmul(x=q, y=k, transpose_y=True, alpha=self.head_dim**-0.5)
+        product = paddle.matmul(x=q * (self.head_dim**-0.5), y=k, transpose_y=True)
 
         # if attn_mask is not None:
         # product = product + attn_mask

examples/language_model/gpt-3/static/modeling.py

@@ -13,20 +13,18 @@
 # limitations under the License.
 
 import collections
-import math
 
-import numpy as np
 import paddle
+import paddle.incubate as incubate
 import paddle.nn as nn
 import paddle.nn.functional as F
 import paddle.tensor as tensor
+from paddle.distributed.fleet import fleet
 from paddle.fluid import layers
 from paddle.nn.layer.transformer import _convert_param_attr_to_list
-from paddle.distributed.fleet import fleet
-import paddle.incubate as incubate
 
-from paddlenlp.transformers import PretrainedModel, register_base_model
 import paddlenlp
+from paddlenlp.transformers import PretrainedModel, register_base_model
 
 __all__ = ["GPTModel", "GPTForPretraining", "GPTPretrainingCriterion", "GPTForGeneration"]
 
@@ -154,7 +152,7 @@ def _prepare_qkv(self, query, key, value, use_cache=False, cache=None):
             k = tensor.concat([cache.k, k], axis=2)
             v = tensor.concat([cache.v, v], axis=2)
 
-            ## if not assign here, assign in While loop
+            # if not assign here, assign in While loop
             # layers.assign(k, cache.k)    # update caches
             # layers.assign(v, cache.v)
 
@@ -220,7 +218,7 @@ def forward(self, query, key, value, attn_mask=None, use_cache=False, cache=None
         else:
             q, k, v, cache = self._prepare_qkv(query, key, value, use_cache, cache)
         # scale dot product attention
-        product = layers.matmul(x=q, y=k, transpose_y=True, alpha=self.head_dim**-0.5)
+        product = paddle.matmul(x=q * (self.head_dim**-0.5), y=k, transpose_y=True)
 
         if self.training:
             weights = incubate.softmax_mask_fuse_upper_triangle(product)
@@ -424,7 +422,7 @@ def forward(self, tgt, memory, tgt_mask=None, use_cache=False, cache=None):
             if isinstance(cache, self.Cache):
                 attn_output, cache_kv_out = self.self_attn(tgt, attn_mask=tgt_mask, cache=cache.kv)
 
-                ## if not assign here, update caches in While loop
+                # if not assign here, update caches in While loop
                 # layers.assign(cache_kv_out, cache.kv)
                 if use_cache:
                     cache = self.Cache(cache_kv_out)
@@ -1069,7 +1067,7 @@ def forward(self, inputs, use_cache=False, cache=None):
             inputs (dict): include src_ids.
                 pos_ids, input_mask and max_dec_len are optional.
         """
-        ######### forward context #########
+        # forward context
         input_ids = inputs["src_ids"]
         position_ids = inputs["pos_ids"] if "pos_ids" in inputs else None
         attention_mask = inputs["input_mask"] if "input_mask" in inputs else None
@@ -1092,13 +1090,12 @@ def forward(self, inputs, use_cache=False, cache=None):
         logits, cached_kvs = self.model(input_ids, position_ids, encode_mask, use_cache=True, cache=gen_caches)
 
         next_id = paddle.argmax(logits[:, -1, :], axis=-1).reshape([-1, 1])
-        ####################################
 
         if "max_dec_len" not in inputs:
             max_len = layers.fill_constant([1], dtype=int_type, value=self.max_dec_len, force_cpu=True)
         else:
             max_len = inputs["max_dec_len"]
-        min_len = layers.fill_constant(shape=[1], dtype=int_type, value=self.min_dec_len, force_cpu=True)
+        # min_len = layers.fill_constant(shape=[1], dtype=int_type, value=self.min_dec_len, force_cpu=True)
         step_idx = layers.fill_constant(shape=[1], value=0, dtype="int64", force_cpu=True)
 
         placehold_ids = layers.fill_constant_batch_size_like(
@@ -1108,7 +1105,7 @@ def forward(self, inputs, use_cache=False, cache=None):
 
         if "max_dec_len" in inputs:
             max_len = paddle.tensor.creation._memcpy(max_len, place=paddle.CPUPlace())
-        cond_int = paddle.full([1], 0, dtype=int_type, name="cond_int")
+        # cond_int = paddle.full([1], 0, dtype=int_type, name="cond_int")
         cond = paddle.less_than(step_idx, max_len)
 
         if attention_mask is not None:

paddlenlp/transformers/ofa_utils.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
+
 import numpy as np
 import paddle
 import paddle.nn as nn
@@ -30,7 +30,7 @@
 
 def prepare_qkv_ofa(self, query, key, value, cache=None):
     q = self.q_proj(query)
-    if hasattr(self.q_proj, "fn") and self.q_proj.fn.cur_config["expand_ratio"] != None:
+    if hasattr(self.q_proj, "fn") and self.q_proj.fn.cur_config["expand_ratio"] is not None:
         self.num_heads = int(self.num_heads * self.q_proj.fn.cur_config["expand_ratio"])
     q = paddle.reshape(x=q, shape=[0, 0, self.num_heads, self.head_dim])
     q = paddle.transpose(x=q, perm=[0, 2, 1, 3])
@@ -64,8 +64,7 @@ def mha_ofa_forward(self, query, key, value, attn_mask=None, cache=None):
         q, k, v, cache = self._prepare_qkv(query, key, value, cache)
 
     # scale dot product attention
-    # TODO: use paddle.matmul, however it doesn't support `alpha`
-    product = paddle.fluid.layers.matmul(x=q, y=k, transpose_y=True, alpha=self.head_dim**-0.5)
+    product = paddle.matmul(x=q * (self.head_dim**-0.5), y=k, transpose_y=True)
     if attn_mask[0] is not None:
         # TODO(guosheng): support bool mask
         product = product + attn_mask[0]
@@ -91,7 +90,7 @@ def mha_ofa_forward(self, query, key, value, attn_mask=None, cache=None):
     if cache is not None:
         outs.append(cache)
 
-    if hasattr(self.q_proj, "fn") and self.q_proj.fn.cur_config["expand_ratio"] != None:
+    if hasattr(self.q_proj, "fn") and self.q_proj.fn.cur_config["expand_ratio"] is not None:
         self.num_heads = int(float(self.num_heads) / self.q_proj.fn.cur_config["expand_ratio"])
     return out if len(outs) == 1 else tuple(outs)