update demo code in NLLLoss_cn.rst for the paddlepaddle2.0

update demo code in NLLLoss_cn.rst

doc/fluid/api/nn/functional.rst

@@ -6,3 +6,4 @@ functional
     :maxdepth: 1
 
     functional/l1_loss.rst
+    functional/nll_loss.rst

doc/fluid/api/nn/functional/nll_loss.rst

+.. _api_nn_functional_nll_loss:
+
+nll_loss
+-------------------------------
+
+..  autoclass:: paddle.nn.functional.nll_loss
+    :members:
+    :inherited-members:
+    :noindex:
+

doc/fluid/api/nn/loss/NLLLoss.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_nn_loss_NLLLoss:
+
+NLLLoss
+-------------------------------
+
+..  autoclass:: paddle.nn.loss.NLLLoss
+    :members:
+    :inherited-members:
+    :noindex:
+

doc/fluid/api_cn/nn_cn/functional_cn.rst

@@ -9,3 +9,4 @@ functional
     :maxdepth: 1
 
     functional_cn/l1_loss_cn.rst
+    functional_cn/nll_loss_cn.rst

doc/fluid/api_cn/nn_cn/functional_cn/nll_loss_cn.rst

+.. _cn_api_nn_functional_nll_loss:
+
+nll_loss
+-------------------------------
+.. py:function:: paddle.nn.functional.nll_loss(input, label, weight=None, ignore_index=-100, reduction='mean', name=None)
+
+该接口返回 `negative log likelihood` 。可在 :ref:`cn_api_nn_loss_NLLLoss` 查看详情。
+
+参数
+:::::::::
+    - **input** (Tensor): - 输入 `Tensor`, 其形状为 :math:`[N, C]` , 其中 `C` 为类别数。但是对于多维度的情形下，它的形状为 :math:`[N, C, d_1, d_2, ..., d_K]` 。数据类型为float32或float64。
+    - **label** (Tensor): - 输入x对应的标签值。其形状为 :math:`[N,]` 或者 :math:`[N, d_1, d_2, ..., d_K]`, 数据类型为int64。
+    - **weight** (Tensor, 可选): - 手动指定每个类别的权重。其默认为 `None` 。如果提供该参数的话，长度必须为 `num_classes` 。数据类型为float32或float64。
+    - **ignore_index** (int64, 可选): - 指定一个忽略的标签值，此标签值不参与计算。默认值为-100。数据类型为int64。
+    - **reduction** (str, 可选): - 指定应用于输出结果的计算方式，可选值有: `none`, `mean`, `sum` 。默认为 `mean` ，计算 `mini-batch` loss均值。设置为 `sum` 时，计算 `mini-batch` loss的总和。设置为 `none` 时，则返回loss Tensor。数据类型为string。
+    - **name** (str, 可选） - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name` 。
+
+返回
+:::::::::
+`Tensor` ，返回存储表示 `negative log likelihood loss` 的损失值。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+        import paddle
+        import numpy as np
+        from paddle.nn.functional import nll_loss
+        log_softmax = paddle.nn.LogSoftmax(axis=1)
+        
+        input_np = np.array([[0.88103855, 0.9908683 , 0.6226845 ],
+                         [0.53331435, 0.07999352, 0.8549948 ],
+                         [0.25879037, 0.39530203, 0.698465  ],
+                         [0.73427284, 0.63575995, 0.18827209],
+                         [0.05689114, 0.0862954 , 0.6325046 ]]).astype(np.float32)
+        label_np = np.array([0, 2, 1, 1, 0]).astype(np.int64)
+
+        place = paddle.CPUPlace()
+        paddle.disable_static(place)
+        input = paddle.to_variable(input_np)
+        log_out = log_softmax(input)
+        label = paddle.to_variable(label_np)
+        result = nll_loss(log_out, label)
+        print(result.numpy()) # [1.0720209]

doc/fluid/api_cn/nn_cn/loss_cn/NLLLoss_cn.rst

+.. _cn_api_nn_loss_NLLLoss:
+
 NLLLoss
 -------------------------------
 
-.. py:function:: paddle.nn.loss.NLLLoss(weight=None, reduction='mean', ignore_index=-100)
+.. py:class:: paddle.nn.loss.NLLLoss(weight=None, ignore_index=-100, reduction='mean', name=None)
 
-该OP计算输入input和标签label间的 `negative log likelihood loss` 损失 ，可用于训练一个 `n` 类分类器。
+该接口可创建一个NLLLoss可调用类，计算输入x和标签label间的 `negative log likelihood loss` 损失 ，可用于训练一个 `n` 类分类器。
 
 如果提供 `weight` 参数的话，它是一个 `1-D` 的tensor, 里面的值对应类别的权重。当你的训练集样本
 不均衡的话，使用这个参数是非常有用的。
@@ -28,48 +30,41 @@ NLLLoss
             \text{if reduction} = \text{'sum'.}
         \end{cases}
 
-参数：
-    - **input** (Variable): - 输入 `Tensor`, 其形状为 :math:`[N, C]` , 其中 `C` 为类别数。但是对于多维度的情形下，它的形状为 :math:`[N, C, d_1, d_2, ..., d_K]` 。数据类型为float32或float64。
-    - **label** (Variable): - 输入input对应的标签值。其形状为 :math:`[N,]` 或者 :math:`[N, d_1, d_2, ..., d_K]`, 数据类型为int64。
-    - **weight** (Variable, 可选): - 手动指定每个类别的权重。其默认为 `None` 。如果提供该参数的话，长度必须为 `num_classes` 。数据类型为float32或float64。
-    - **reduction** (string, 可选): - 指定应用于输出结果的计算方式，可选值有: `none`, `mean`, `sum` 。默认为 `mean` ，计算 `mini-batch` loss均值。设置为 `sum` 时，计算 `mini-batch` loss的总和。设置为 `none` 时，则返回loss Tensor。数据类型为string。
+参数
+:::::::::
+    - **weight** (Tensor, 可选): - 手动指定每个类别的权重。其默认为 `None` 。如果提供该参数的话，长度必须为 `num_classes` 。数据类型为float32或float64。
     - **ignore_index** (int64, 可选): - 指定一个忽略的标签值，此标签值不参与计算。默认值为-100。数据类型为int64。
+    - **reduction** (str, 可选): - 指定应用于输出结果的计算方式，可选值有: `none`, `mean`, `sum` 。默认为 `mean` ，计算 `mini-batch` loss均值。设置为 `sum` 时，计算 `mini-batch` loss的总和。设置为 `none` 时，则返回loss Tensor。数据类型为string。
+    - **name** (str, 可选） - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name` 。
 
-返回：返回存储表示 `negative log likihood loss` 的损失值。
-
-返回类型：Variable
+形状
+:::::::::
+    - **input** (Tensor): - 输入 `Tensor`, 其形状为 :math:`[N, C]` , 其中 `C` 为类别数。但是对于多维度的情形下，它的形状为 :math:`[N, C, d_1, d_2, ..., d_K]` 。数据类型为float32或float64。
+    - **label** (Tensor): - 输入 `input` 对应的标签值。其形状为 :math:`[N,]` 或者 :math:`[N, d_1, d_2, ..., d_K]`, 数据类型为int64。
+    - **output** (Tensor): - 输入 `input` 和 `label` 间的 `negative log likelihood loss` 损失。如果 `reduction` 为 `'none'` ，则输出Loss形状为 `[N, *]` 。 如果 `reduction` 为 `'sum'` 或者 `'mean'` ，则输出Loss形状为 `'[1]'` 。
 
-**代码示例**
+代码示例
+:::::::::
 
 .. code-block:: python
 
-            # declarative mode
-            import paddle.fluid as fluid
-            import numpy as np
         import paddle
-            input_np = np.random.random(size=(10, 10)).astype(np.float32)
-            label_np = np.random.randint(0, 10, size=(10,)).astype(np.int64)
-            prog = fluid.Program()
-            startup_prog = fluid.Program()
-            place = fluid.CPUPlace()
-            with fluid.program_guard(prog, startup_prog):
-                input = fluid.data(name='input', shape=[10, 10], dtype='float32')
-                label = fluid.data(name='label', shape=[10], dtype='int64')
-                nll_loss = paddle.nn.loss.NLLLoss()
-                res = nll_loss(input, label)
-                exe = fluid.Executor(place)
-                static_result = exe.run(
-                    prog,
-                    feed={"input": input_np,
-                          "label": label_np},
-                    fetch_list=[res])
-            print(static_result)
-            
-            # imperative mode
-            import paddle.fluid.dygraph as dg
-            with dg.guard(place) as g:
-                input = dg.to_variable(input_np)
-                label = dg.to_variable(label_np)
-                output = nll_loss(input, label)
-                print(output.numpy())
+        import numpy as np
 
+        nll_loss = paddle.nn.layer.NLLLoss()
+        log_softmax = paddle.nn.LogSoftmax(axis=1)
+
+        input_np = np.array([[0.88103855, 0.9908683 , 0.6226845 ],
+                         [0.53331435, 0.07999352, 0.8549948 ],
+                         [0.25879037, 0.39530203, 0.698465  ],
+                         [0.73427284, 0.63575995, 0.18827209],
+                         [0.05689114, 0.0862954 , 0.6325046 ]]).astype(np.float32)
+        label_np = np.array([0, 2, 1, 1, 0]).astype(np.int64)
+
+        place = paddle.CPUPlace()
+        paddle.disable_static(place)
+        input = paddle.to_variable(input_np)
+        log_out = log_softmax(input)
+        label = paddle.to_variable(label_np)
+        result = nll_loss(log_out, label)
+        print(result.numpy()) # [1.0720209]