add embedding 2.0

python/paddle/fluid/input.py

@@ -129,6 +129,7 @@ def one_hot(input, depth, allow_out_of_range=False):
     return one_hot_out
 
 
+@deprecated(since='2.0.0', update_to='paddle.nn.functional.embedding')
 def embedding(input,
               size,
               is_sparse=False,

python/paddle/fluid/layers/nn.py

@@ -367,6 +367,7 @@ def fc(input,
     return helper.append_activation(pre_activation)
 
 
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.embedding")
 def embedding(input,
               size,
               is_sparse=False,

python/paddle/fluid/tests/unittests/test_nn_functional_embedding.py

@@ -0,0 +1,69 @@
+#   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import unittest
+import numpy as np
+import paddle.fluid as fluid
+import paddle.nn.functional as functional
+
+
+class EmbeddingStatic(unittest.TestCase):
+    def test_1(self):
+        prog = fluid.Program()
+        with fluid.program_guard(prog):
+
+            def test_bad_x():
+                initializer = fluid.initializer.NumpyArrayInitializer(
+                    np.random.random(size=(128, 100)))
+
+                param_attr = fluid.ParamAttr(
+                    name="emb_weight",
+                    learning_rate=0.5,
+                    initializer=initializer,
+                    trainable=True)
+
+                weight = prog.global_block().create_parameter(
+                    (128, 100), attr=param_attr, dtype="float32")
+
+                label = fluid.layers.data(
+                    name="label",
+                    shape=[4],
+                    append_batch_size=False,
+                    dtype="int64")
+
+                emb = functional.embedding(
+                    x=label, weight=weight, sparse=True, name="embedding")
+
+            test_bad_x()
+
+
+class EmbeddingDygraph(unittest.TestCase):
+    def test_1(self):
+        import paddle
+        import paddle.nn as nn
+        import numpy as np
+        paddle.disable_static()
+
+        # example 1
+        inp_word = np.array([[2, 3, 5], [4, 2, 1]]).astype('int64')
+        inp_word.shape  # [2, 3]
+        dict_size = 20
+
+        emb = nn.Embedding(dict_size, 32, weight_attr='emb.w', sparse=False)
+
+
+if __name__ == '__main__':
+    unittest.main()

python/paddle/nn/functional/__init__.py

@@ -227,3 +227,4 @@
 from .vision import yolo_box  #DEFINE_ALIAS
 from .vision import yolov3_loss  #DEFINE_ALIAS
 from .input import one_hot  #DEFINE_ALIAS
+from .input import embedding  #DEFINE_ALIAS

python/paddle/nn/functional/input.py

@@ -19,7 +19,7 @@
 from ...fluid.layers import core
 from ...fluid.data_feeder import check_variable_and_dtype, check_dtype
 
-__all__ = ['one_hot']
+__all__ = ['one_hot', 'embedding']
 
 
 def one_hot(x, num_classes, name=None):
@@ -83,6 +83,7 @@ def one_hot(x, num_classes, name=None):
             #                       [0., 1., 0., 0.],
             #                       [0., 0., 0., 1.],
             #                       [1., 0., 0., 0.]]
+
     """
 
     if in_dygraph_mode():
@@ -108,3 +109,101 @@ def one_hot(x, num_classes, name=None):
             outputs={'Out': one_hot_out},
             stop_gradient=True)
         return one_hot_out
+
+
+def embedding(x, weight, padding_idx=None, sparse=False, name=None):
+    """
+        The operator is used to lookup embeddings vector of ids provided by :attr:`input` .
+
+        The shape of output Tensor is generated by appending the last dimension of the input Tensor shape
+        with emb_size.
+        **Note:** The id in :attr:`input` must satisfy :math:`0 =< id < size[0]` ,
+        otherwise the program will throw an exception and exit.
+        .. code-block:: text
+
+            Case 1:
+            input is a Tensor. padding_idx = -1
+                input.data = [[1, 3], [2, 4], [4, 127]]
+                input.shape = [3, 2]
+            Given size = [128, 16]
+            output is a Tensor:
+                out.shape = [3, 2, 16]
+                out.data = [[[0.129435295, 0.244512452, ..., 0.436322452],
+                            [0.345421456, 0.524563927, ..., 0.144534654]],
+                            [[0.345249859, 0.124939536, ..., 0.194353745],
+                            [0.945345345, 0.435394634, ..., 0.435345365]],
+                            [[0.945345345, 0.435394634, ..., 0.435345365],
+                            [0.0,         0.0,         ..., 0.0        ]]]  # padding data
+            The input padding_idx is less than 0, it is automatically converted to padding_idx = -1 + 128 = 127
+            It will pad all-zero data when ids is 127.
+
+        Args:
+            x(Tensor): A Tensor or LoDTensor with type int64, which contains the id information.
+                The last dimension of Tensor shape must be equal to 1. The value of the input id should
+                satisfy :math:`0<= id < size[0]` .
+            weight (Tensor): The weight. A Tensor with shape of lookup table parameter. It should have two elements which
+                indicates the size of the dictionary of embeddings and the size of each embedding vector respectively.
+            sparse(bool): The flag indicating whether to use sparse update. This parameter only
+                affects the performance of the backwards gradient update. It is recommended to set
+                True because sparse update is faster. But some optimizers does not support sparse update,
+                such as :ref:`api_fluid_optimizer_AdadeltaOptimizer` , :ref:`api_fluid_optimizer_AdamaxOptimizer` ,
+                :ref:`api_fluid_optimizer_DecayedAdagradOptimizer` , :ref:`api_fluid_optimizer_FtrlOptimizer` ,
+                :ref:`api_fluid_optimizer_LambOptimizer` and :ref:`api_fluid_optimizer_LarsMomentumOptimizer` .
+                In these cases, is_sparse must be False. Default: False.
+            padding_idx(int|long|None): padding_idx needs to be in the interval [-vocab_size, vocab_size).
+                If :math:`padding\_idx < 0`, the :math:`padding\_idx` will automatically be converted
+                to :math:`vocab\_size + padding\_idx` . It will output all-zero padding data whenever lookup
+                encounters :math:`padding\_idx` in id. And the padding data will not be updated while training.
+                If set None, it makes no effect to output. Default: None.
+            name(str|None): For detailed information, please refer
+               to :ref:`api_guide_Name`. Usually name is no need to set and
+               None by default.
+
+        Returns:
+            Tensor: Embedding Tensor  mapped by input. The data type is the same as :attr:`weight`.
+
+        Examples:
+            .. code-block:: python
+
+                import paddle
+                import paddle.nn as nn
+                import numpy as np
+                paddle.disable_static()
+
+                # example 1
+                inp_word = np.array([[2, 3, 5], [4, 2, 1]]).astype('int64')
+                inp_word.shape  # [2, 3]
+                dict_size = 20
+
+                emb = nn.Embedding(dict_size, 32, weight_attr='emb.w', sparse=False)
+
+    """
+    if in_dygraph_mode():
+        return core.ops.lookup_table_v2(
+            weight, x, 'is_sparse', sparse, 'is_distributed', False,
+            'remote_prefetch', False, 'padding_idx', padding_idx)
+    else:
+        helper = LayerHelper('embedding', **locals())
+        dtype = helper.input_dtype()
+
+        check_variable_and_dtype(x, 'input', ['int64'], 'embedding')
+
+        is_distributed = False
+        remote_prefetch = sparse and (not is_distributed)
+
+        tmp = helper.create_variable_for_type_inference(dtype)
+        padding_idx = -1 if padding_idx is None else padding_idx if padding_idx >= 0 else (
+            weight.shape[0] + padding_idx)
+
+        helper.append_op(
+            type='lookup_table_v2',
+            inputs={'Ids': x,
+                    'W': weight},
+            outputs={'Out': tmp},
+            attrs={
+                'is_sparse': sparse,
+                'is_distributed': is_distributed,
+                'remote_prefetch': remote_prefetch,
+                'padding_idx': padding_idx
+            })
+        return tmp