text: # 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
  from op_test import OpTest, convert_float_to_uint16
  import paddle
  import paddle.fluid as fluid
  import paddle.fluid.core as core
  
  
  def p_norm(x, axis, porder, keepdims=False, reduce_all=False):
      r = []
      if axis is None or reduce_all:
          x = x.flatten()
          if porder == np.inf:
              r = np.amax(np.abs(x), keepdims=keepdims)
          elif porder == -np.inf:
              r = np.amin(np.abs(x), keepdims=keepdims)
          else:
              r = np.linalg.norm(x, ord=porder, keepdims=keepdims)
      elif isinstance(axis, list or tuple) and len(axis) == 2:
          if porder == np.inf:
              axis = tuple(axis)
              r = np.amax(np.abs(x), axis=axis, keepdims=keepdims)
          elif porder == -np.inf:
              axis = tuple(axis)
              r = np.amin(np.abs(x), axis=axis, keepdims=keepdims)
          elif porder == 0:
              axis = tuple(axis)
              r = x.astype(bool)
              r = np.sum(r, axis, keepdims=keepdims)
          elif porder == 1:
              axis = tuple(axis)
              r = np.sum(np.abs(x), axis, keepdims=keepdims)
          else:
              axis = tuple(axis)
              xp = np.power(np.abs(x), porder)
              s = np.sum(xp, axis=axis, keepdims=keepdims)
              r = np.power(s, 1.0 / porder)
      else:
          if isinstance(axis, list):
              axis = tuple(axis)
          r = np.linalg.norm(x, ord=porder, axis=axis, keepdims=keepdims)
      r = r.astype(x.dtype)
  
      return r
  
  
  def frobenius_norm(x, axis=None, keepdims=False):
      if isinstance(axis, list): axis = tuple(axis)
      if axis is None: x = x.reshape(1, x.size)
      r = np.linalg.norm(
          x, ord='fro', axis=axis, keepdims=keepdims).astype(x.dtype)
      return r
  
  
  class TestFrobeniusNormOp(OpTest):
      def setUp(self):
          self.op_type = "frobenius_norm"
          self.init_test_case()
          x = (np.random.random(self.shape) + 1.0).astype(self.dtype)
          norm = frobenius_norm(x, self.axis, self.keepdim)
          self.reduce_all = (len(self.axis) == len(self.shape))
          self.inputs = {'X': x}
          self.attrs = {
              'dim': list(self.axis),
              'keep_dim': self.keepdim,
              'reduce_all': self.reduce_all
          }
          self.outputs = {'Out': norm}
  
      def test_check_output(self):
          self.check_output()
  
      def test_check_grad(self):
          self.check_grad(['X'], 'Out')
  
      def init_test_case(self):
          self.shape = [2, 3, 4, 5]
          self.axis = (1, 2)
          self.keepdim = False
          self.dtype = "float64"
  
  
  class TestFrobeniusNormOp2(TestFrobeniusNormOp):
      def init_test_case(self):
          self.shape = [5, 5, 5]
          self.axis = (0, 1)
          self.keepdim = True
          self.dtype = "float32"
  
      def test_check_grad(self):
          self.check_grad(['X'], 'Out')
  
  
  class TestPnormOp(OpTest):
      def setUp(self):
          self.op_type = "p_norm"
          self.init_test_case()
          x = (np.random.random(self.shape) + 0.5).astype(self.dtype)
          norm = p_norm(x, self.axis, self.porder, self.keepdim, self.asvector)
          self.inputs = {'X': x}
          self.attrs = {
              'epsilon': self.epsilon,
              'axis': self.axis,
              'keepdim': self.keepdim,
              'porder': float(self.porder),
              'asvector': self.asvector
          }
          self.outputs = {'Out': norm}
          self.gradient = self.calc_gradient()
  
      def test_check_output(self):
          self.check_output()
  
      def test_check_grad(self):
          self.check_grad(['X'], 'Out')
  
      def init_test_case(self):
          self.shape = [2, 3, 4, 5]
          self.axis = 1
          self.epsilon = 1e-12
          self.porder = 2.0
          self.keepdim = False
          self.dtype = "float64"
          self.asvector = False
  
      def calc_gradient(self):
          self.attrs = {
              'epsilon': self.epsilon,
              'axis': self.axis,
              'keepdim': self.keepdim,
              'porder': float(self.porder),
              'asvector': self.asvector
          }
          x = self.inputs["X"]
          porder = self.attrs["porder"]
          axis = self.attrs["axis"]
          asvector = self.attrs["asvector"]
          x_dtype = x.dtype
          x = x.astype(np.float32) if x.dtype == np.float16 else x
          if porder == 0:
              grad = np.zeros(x.shape).astype(x.dtype)
          elif porder in [float("inf"), float("-inf")]:
              norm = p_norm(
                  x, axis=axis, porder=porder, keepdims=True, reduce_all=asvector)
              x_abs = np.abs(x)
              grad = np.sign(x)
              grad[x_abs != norm] = 0.0
          else:
              norm = p_norm(
                  x, axis=axis, porder=porder, keepdims=True, reduce_all=asvector)
              grad = np.power(norm, 1 - porder) * np.power(
                  np.abs(x), porder - 1) * np.sign(x)
  
          numel = 1
          for s in x.shape:
              numel *= s
          divisor = numel if asvector else x.shape[axis]
          numel /= divisor
          return [grad.astype(x_dtype) * 1 / numel]
  
  
  class TestPnormOp2(TestPnormOp):
      def init_test_case(self):
          self.shape = [3, 20, 3]
          self.axis = 2
          self.epsilon = 1e-12
          self.porder = 2.0
          self.keepdim = True
          self.dtype = "float32"
          self.asvector = False
  
      def test_check_grad(self):
          self.check_grad(['X'], 'Out')
  
  
  class TestPnormOp3(TestPnormOp):
      def init_test_case(self):
          self.shape = [3, 20, 3]
          self.axis = 2
          self.epsilon = 1e-12
          self.porder = np.inf
          self.keepdim = True
          self.dtype = "float32"
          self.asvector = False
  
      def test_check_grad(self):
          self.check_grad(['X'], 'Out', user_defined_grads=self.gradient)
  
  
  class TestPnormOp4(TestPnormOp):
      def init_test_case(self):
          self.shape = [3, 20, 3]
          self.axis = 2
          self.epsilon = 1e-12
          self.porder = -np.inf
          self.keepdim = True
          self.dtype = "float32"
          self.asvector = False
  
      def test_check_grad(self):
          self.check_grad(['X'], 'Out', user_defined_grads=self.gradient)
  
  
  class TestPnormOp5(TestPnormOp):
      def init_test_case(self):
          self.shape = [3, 20, 3]
          self.axis = 2
          self.epsilon = 1e-12
          self.porder = 0
          self.keepdim = True
          self.dtype = "float32"
          self.asvector = False
  
      def test_check_grad(self):
          self.check_grad(['X'], 'Out', user_defined_grads=self.gradient)
  
  
  class TestPnormOp6(TestPnormOp):
      def init_test_case(self):
          self.shape = [3, 20, 3]
          self.axis = -1
          self.epsilon = 1e-12
          self.porder = 2
          self.keepdim = False
          self.dtype = "float32"
          self.asvector = True
  
      def test_check_grad(self):
          self.check_grad(['X'], 'Out', user_defined_grads=self.gradient)
  
  
  @unittest.skipIf(not core.is_compiled_with_cuda(),
                   "core is not compiled with CUDA")
  class TestPnormOpFP16(TestPnormOp):
      def init_test_case(self):
          self.shape = [2, 3, 4, 5]
          self.axis = 1
          self.epsilon = 1e-12
          self.porder = 2.0
          self.keepdim = False
          self.dtype = "float16"
          self.asvector = False
  
      def test_check_output(self):
          place = core.CUDAPlace(0)
          if core.is_float16_supported(place):
              self.check_output_with_place(place, atol=1e-3)
  
      def test_check_grad(self):
          place = core.CUDAPlace(0)
          if core.is_float16_supported(place):
              self.check_grad_with_place(
                  place, ['X'], 'Out', user_defined_grads=self.gradient)
  
  
  @unittest.skipIf(not core.is_compiled_with_cuda(),
                   "core is not compiled with CUDA")
  class TestPnormOpFP161(TestPnormOpFP16):
      def init_test_case(self):
          self.shape = [2, 3, 4, 5]
          self.axis = -1
          self.epsilon = 1e-12
          self.porder = 2.0
          self.keepdim = False
          self.dtype = "float16"
          self.asvector = True
  
  
  @unittest.skipIf(not core.is_compiled_with_cuda(),
                   "core is not compiled with CUDA")
  class TestPnormBF16Op(OpTest):
      def setUp(self):
          self.op_type = "p_norm"
          self.init_test_case()
          self.x = (np.random.random(self.shape) + 0.5).astype(np.float32)
          self.norm = p_norm(self.x, self.axis, self.porder, self.keepdim,
                             self.asvector)
          self.gradient = self.calc_gradient()
          self.inputs = {'X': convert_float_to_uint16(self.x)}
          self.attrs = {
              'epsilon': self.epsilon,
              'axis': self.axis,
              'keepdim': self.keepdim,
              'porder': float(self.porder),
              'asvector': self.asvector
          }
          self.outputs = {'Out': convert_float_to_uint16(self.norm)}
  
      def test_check_output(self):
          place = core.CUDAPlace(0)
          self.check_output_with_place(place, atol=1e-3)
  
      def test_check_grad(self):
          place = core.CUDAPlace(0)
          self.check_grad_with_place(
              place, ['X'], 'Out', user_defined_grads=self.gradient)
  
      def init_test_case(self):
          self.shape = [2, 3, 4, 5]
          self.axis = 1
          self.epsilon = 1e-12
          self.porder = 2.0
          self.keepdim = False
          self.dtype = np.uint16
          self.asvector = False
  
      def calc_gradient(self):
          self.attrs = {
              'epsilon': self.epsilon,
              'axis': self.axis,
              'keepdim': self.keepdim,
              'porder': float(self.porder),
              'asvector': self.asvector
          }
          x = self.x
          porder = self.attrs["porder"]
          axis = self.attrs["axis"]
          asvector = self.attrs["asvector"]
          x_dtype = x.dtype
          x = x.astype(np.float32) if x.dtype == np.float16 else x
          if porder == 0:
              grad = np.zeros(x.shape).astype(x.dtype)
          elif porder in [float("inf"), float("-inf")]:
              norm = p_norm(
                  x, axis=axis, porder=porder, keepdims=True, reduce_all=asvector)
              x_abs = np.abs(x)
              grad = np.sign(x)
              grad[x_abs != norm] = 0.0
          else:
              norm = p_norm(
                  x, axis=axis, porder=porder, keepdims=True, reduce_all=asvector)
              grad = np.power(norm, 1 - porder) * np.power(
                  np.abs(x), porder - 1) * np.sign(x)
  
          numel = 1
          for s in x.shape:
              numel *= s
          divisor = numel if asvector else x.shape[axis]
          numel /= divisor
          return [grad.astype(x_dtype) * 1 / numel]
  
  
  def run_fro(self, p, axis, shape_x, dtype, keep_dim, check_dim=False):
      with fluid.program_guard(fluid.Program()):
          data = fluid.data(name="X", shape=shape_x, dtype=dtype)
          out = paddle.norm(x=data, p=p, axis=axis, keepdim=keep_dim)
          place = fluid.CPUPlace()
          exe = fluid.Executor(place)
          np_input = (np.random.rand(*shape_x) + 1.0).astype(dtype)
          expected_result = frobenius_norm(np_input, axis=axis, keepdims=keep_dim)
          result, = exe.run(feed={"X": np_input}, fetch_list=[out])
      self.assertEqual((np.abs(result - expected_result) < 1e-6).all(), True)
      if keep_dim and check_dim:
          self.assertEqual(
              (np.abs(np.array(result.shape) - np.array(expected_result.shape)) <
               1e-6).all(), True)
  
  
  def run_pnorm(self, p, axis, shape_x, dtype, keep_dim, check_dim=False):
      with fluid.program_guard(fluid.Program()):
          data = fluid.data(name="X", shape=shape_x, dtype=dtype)
          out = paddle.norm(x=data, p=p, axis=axis, keepdim=keep_dim)
          place = fluid.CPUPlace()
          exe = fluid.Executor(place)
          np_input = (np.random.rand(*shape_x) + 1.0).astype(dtype)
          expected_result = p_norm(
              np_input, porder=p, axis=axis, keepdims=keep_dim).astype(dtype)
          result, = exe.run(feed={"X": np_input}, fetch_list=[out])
      self.assertEqual((np.abs(result - expected_result) < 1e-6).all(), True)
      if keep_dim and check_dim:
          self.assertEqual(
              (np.abs(np.array(result.shape) - np.array(expected_result.shape)) <
               1e-6).all(), True)
  
  
  def run_graph(self, p, axis, shape_x, dtype):
      paddle.disable_static()
      shape = [2, 3, 4]
      np_input = np.arange(24).astype('float32') - 12
      np_input = np_input.reshape(shape)
      x = paddle.to_tensor(np_input)
      #[[[-12. -11. -10.  -9.] [ -8.  -7.  -6.  -5.] [ -4.  -3.  -2.  -1.]]
      # [[  0.   1.   2.   3.] [  4.   5.   6.   7.] [  8.   9.  10.  11.]]]
      out_pnorm = paddle.norm(x, p=2, axis=-1)
  
      # compute frobenius norm along last two dimensions.
      out_fro = paddle.norm(x, p='fro')
      out_fro = paddle.norm(x, p='fro', axis=0)
      out_fro = paddle.norm(x, p='fro', axis=[0, 1])
      # compute 2-order  norm along [0,1] dimension.
      out_pnorm = paddle.norm(x, p=2, axis=[0, 1])
      out_pnorm = paddle.norm(x, p=2)
      #out_pnorm = [17.43559577 16.91153453 16.73320053 16.91153453]
      # compute inf-order  norm
      out_pnorm = paddle.norm(x, p=np.inf)
      #out_pnorm = [12.]
      out_pnorm = paddle.norm(x, p=np.inf, axis=0)
      #out_pnorm = [[0. 1. 2. 3.] [4. 5. 6. 5.] [4. 3. 2. 1.]]
  
      # compute -inf-order  norm
      out_pnorm = paddle.norm(x, p=-np.inf)
      #out_pnorm = [0.]
      out_pnorm = paddle.norm(x, p=-np.inf, axis=0)
      # out_fro = [17.43559577 16.91153453 16.73320053 16.91153453]
      paddle.enable_static()
  
  
  class API_NormTest(unittest.TestCase):
      def test_basic(self):
          keep_dims = {False, True}
          for keep in keep_dims:
              run_fro(
                  self,
                  p='fro',
                  axis=None,
                  shape_x=[2, 3, 4],
                  dtype="float32",
                  keep_dim=keep)
              run_fro(
                  self,
                  p='fro',
                  axis=[0, 1],
                  shape_x=[2, 3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=2,
                  axis=None,
                  shape_x=[3, 4],
                  dtype="float32",
                  keep_dim=keep)
              run_pnorm(
                  self,
                  p=2,
                  axis=1,
                  shape_x=[3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=np.inf,
                  axis=0,
                  shape_x=[2, 3, 4],
                  dtype="float32",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=np.inf,
                  axis=None,
                  shape_x=[2, 3, 4],
                  dtype="float32",
                  keep_dim=keep)
              run_pnorm(
                  self,
                  p=-np.inf,
                  axis=0,
                  shape_x=[2, 3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=-np.inf,
                  axis=None,
                  shape_x=[2, 3, 4],
                  dtype="float64",
                  keep_dim=keep)
              run_pnorm(
                  self,
                  p=0,
                  axis=1,
                  shape_x=[3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
  
              run_pnorm(
                  self,
                  p=1,
                  axis=1,
                  shape_x=[3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=0,
                  axis=None,
                  shape_x=[3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=2,
                  axis=[0, 1],
                  shape_x=[2, 3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=2,
                  axis=-1,
                  shape_x=[2, 3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=1,
                  axis=[0, 1],
                  shape_x=[2, 3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=np.inf,
                  axis=[0, 1],
                  shape_x=[2, 3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
              run_pnorm(
                  self,
                  p=-np.inf,
                  axis=[0, 1],
                  shape_x=[2, 3, 4],
                  dtype="float64",
                  keep_dim=keep,
                  check_dim=True)
  
      def test_dygraph(self):
          run_graph(self, p='fro', axis=None, shape_x=[2, 3, 4], dtype="float32")
  
      def test_name(self):
          with fluid.program_guard(fluid.Program()):
              x = fluid.data(name="x", shape=[10, 10], dtype="float32")
              y_1 = paddle.norm(x, p='fro', name='frobenius_name')
              y_2 = paddle.norm(x, p=2, name='pnorm_name')
              self.assertEqual(('frobenius_name' in y_1.name), True)
              self.assertEqual(('pnorm_name' in y_2.name), True)
  
      def test_errors(self):
          with fluid.program_guard(fluid.Program(), fluid.Program()):
  
              def err_dtype(p, shape_x, xdtype, out=None):
                  data = fluid.data(shape=shape_x, dtype=xdtype)
                  paddle.norm(data, p=p, out=out)
  
              self.assertRaises(TypeError, err_dtype, "fro", [2, 2], "int64")
              self.assertRaises(ValueError, paddle.norm, "inf", [2], "int64")
              out = fluid.data(name="out", shape=[1], dtype="int64")
              self.assertRaises(TypeError, err_dtype, "fro", [2, 2], "float64",
                                out)
              self.assertRaises(TypeError, err_dtype, 2, [10], "int64")
              self.assertRaises(TypeError, err_dtype, 2, [10], "float64", out)
  
              data = fluid.data(name="data_2d", shape=[2, 2], dtype="float64")
              self.assertRaises(ValueError, paddle.norm, data, p="unsupport norm")
              self.assertRaises(ValueError, paddle.norm, data, p=[1])
              self.assertRaises(ValueError, paddle.norm, data, p=[1], axis=-1)
              self.assertRaises(ValueError, paddle.norm, 0, [1, 0], "float64")
              data = fluid.data(name="data_3d", shape=[2, 2, 2], dtype="float64")
              self.assertRaises(
                  ValueError, paddle.norm, data, p='unspport', axis=[-3, -2, -1])
  
  
  if __name__ == '__main__':
      unittest.main()
  