text: # Copyright (c) 2021 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 typing import Any
  from typing import List
  from typing import Tuple
  from typing import Union
  
  import paddle
  from paddle import nn
  from paddle.fluid import core
  from paddle.nn import functional as F
  
  from deepspeech.utils.log import Log
  
  #TODO(Hui Zhang): remove  fluid import
  logger = Log(__name__).getlog()
  
  ########### hcak logging #############
  logger.warn = logger.warning
  
  ########### hcak paddle #############
  paddle.half = 'float16'
  paddle.float = 'float32'
  paddle.double = 'float64'
  paddle.short = 'int16'
  paddle.int = 'int32'
  paddle.long = 'int64'
  paddle.uint16 = 'uint16'
  paddle.cdouble = 'complex128'
  
  
  def convert_dtype_to_string(tensor_dtype):
      """
      Convert the data type in numpy to the data type in Paddle
      Args:
          tensor_dtype(core.VarDesc.VarType): the data type in numpy.
      Returns:
          core.VarDesc.VarType: the data type in Paddle.
      """
      dtype = tensor_dtype
      if dtype == core.VarDesc.VarType.FP32:
          return paddle.float32
      elif dtype == core.VarDesc.VarType.FP64:
          return paddle.float64
      elif dtype == core.VarDesc.VarType.FP16:
          return paddle.float16
      elif dtype == core.VarDesc.VarType.INT32:
          return paddle.int32
      elif dtype == core.VarDesc.VarType.INT16:
          return paddle.int16
      elif dtype == core.VarDesc.VarType.INT64:
          return paddle.int64
      elif dtype == core.VarDesc.VarType.BOOL:
          return paddle.bool
      elif dtype == core.VarDesc.VarType.BF16:
          # since there is still no support for bfloat16 in NumPy,
          # uint16 is used for casting bfloat16
          return paddle.uint16
      elif dtype == core.VarDesc.VarType.UINT8:
          return paddle.uint8
      elif dtype == core.VarDesc.VarType.INT8:
          return paddle.int8
      elif dtype == core.VarDesc.VarType.COMPLEX64:
          return paddle.complex64
      elif dtype == core.VarDesc.VarType.COMPLEX128:
          return paddle.complex128
      else:
          raise ValueError("Not supported tensor dtype %s" % dtype)
  
  
  if not hasattr(paddle, 'softmax'):
      logger.debug("register user softmax to paddle, remove this when fixed!")
      setattr(paddle, 'softmax', paddle.nn.functional.softmax)
  
  if not hasattr(paddle, 'log_softmax'):
      logger.debug("register user log_softmax to paddle, remove this when fixed!")
      setattr(paddle, 'log_softmax', paddle.nn.functional.log_softmax)
  
  if not hasattr(paddle, 'sigmoid'):
      logger.debug("register user sigmoid to paddle, remove this when fixed!")
      setattr(paddle, 'sigmoid', paddle.nn.functional.sigmoid)
  
  if not hasattr(paddle, 'log_sigmoid'):
      logger.debug("register user log_sigmoid to paddle, remove this when fixed!")
      setattr(paddle, 'log_sigmoid', paddle.nn.functional.log_sigmoid)
  
  if not hasattr(paddle, 'relu'):
      logger.debug("register user relu to paddle, remove this when fixed!")
      setattr(paddle, 'relu', paddle.nn.functional.relu)
  
  
  def cat(xs, dim=0):
      return paddle.concat(xs, axis=dim)
  
  
  if not hasattr(paddle, 'cat'):
      logger.debug(
          "override cat of paddle if exists or register, remove this when fixed!")
      paddle.cat = cat
  
  
  ########### hcak paddle.Tensor #############
  def item(x: paddle.Tensor):
      return x.numpy().item()
  
  
  if not hasattr(paddle.Tensor, 'item'):
      logger.debug(
          "override item of paddle.Tensor if exists or register, remove this when fixed!"
      )
      paddle.Tensor.item = item
  
  
  def func_long(x: paddle.Tensor):
      return paddle.cast(x, paddle.long)
  
  
  if not hasattr(paddle.Tensor, 'long'):
      logger.debug(
          "override long of paddle.Tensor if exists or register, remove this when fixed!"
      )
      paddle.Tensor.long = func_long
  
  if not hasattr(paddle.Tensor, 'numel'):
      logger.debug(
          "override numel of paddle.Tensor if exists or register, remove this when fixed!"
      )
      paddle.Tensor.numel = paddle.numel
  
  
  def new_full(x: paddle.Tensor,
               size: Union[List[int], Tuple[int], paddle.Tensor],
               fill_value: Union[float, int, bool, paddle.Tensor],
               dtype=None):
      return paddle.full(size, fill_value, dtype=x.dtype)
  
  
  if not hasattr(paddle.Tensor, 'new_full'):
      logger.debug(
          "override new_full of paddle.Tensor if exists or register, remove this when fixed!"
      )
      paddle.Tensor.new_full = new_full
  
  
  def eq(xs: paddle.Tensor, ys: Union[paddle.Tensor, float]) -> paddle.Tensor:
      if convert_dtype_to_string(xs.dtype) == paddle.bool:
          xs = xs.astype(paddle.int)
      return xs.equal(
          paddle.to_tensor(
              ys, dtype=convert_dtype_to_string(xs.dtype), place=xs.place))
  
  
  if not hasattr(paddle.Tensor, 'eq'):
      logger.debug(
          "override eq of paddle.Tensor if exists or register, remove this when fixed!"
      )
      paddle.Tensor.eq = eq
  
  if not hasattr(paddle, 'eq'):
      logger.debug(
          "override eq of paddle if exists or register, remove this when fixed!")
      paddle.eq = eq
  
  
  def contiguous(xs: paddle.Tensor) -> paddle.Tensor:
      return xs
  
  
  if not hasattr(paddle.Tensor, 'contiguous'):
      logger.debug(
          "override contiguous of paddle.Tensor if exists or register, remove this when fixed!"
      )
      paddle.Tensor.contiguous = contiguous
  
  
  def size(xs: paddle.Tensor, *args: int) -> paddle.Tensor:
      nargs = len(args)
      assert (nargs <= 1)
      s = paddle.shape(xs)
      if nargs == 1:
          return s[args[0]]
      else:
          return s
  
  
  #`to_static` do not process `size` property, maybe some `paddle` api dependent on it.
  logger.debug(
      "override size of paddle.Tensor "
      "(`to_static` do not process `size` property, maybe some `paddle` api dependent on it), remove this when fixed!"
  )
  paddle.Tensor.size = size
  
  
  def view(xs: paddle.Tensor, *args: int) -> paddle.Tensor:
      return xs.reshape(args)
  
  
  if not hasattr(paddle.Tensor, 'view'):
      logger.debug("register user view to paddle.Tensor, remove this when fixed!")
      paddle.Tensor.view = view
  
  
  def view_as(xs: paddle.Tensor, ys: paddle.Tensor) -> paddle.Tensor:
      return xs.reshape(ys.size())
  
  
  if not hasattr(paddle.Tensor, 'view_as'):
      logger.debug(
          "register user view_as to paddle.Tensor, remove this when fixed!")
      paddle.Tensor.view_as = view_as
  
  
  def is_broadcastable(shp1, shp2):
      for a, b in zip(shp1[::-1], shp2[::-1]):
          if a == 1 or b == 1 or a == b:
              pass
          else:
              return False
      return True
  
  
  def masked_fill(xs: paddle.Tensor,
                  mask: paddle.Tensor,
                  value: Union[float, int]):
      assert is_broadcastable(xs.shape, mask.shape) is True, (xs.shape,
                                                              mask.shape)
      bshape = paddle.broadcast_shape(xs.shape, mask.shape)
      mask = mask.broadcast_to(bshape)
      trues = paddle.ones_like(xs) * value
      xs = paddle.where(mask, trues, xs)
      return xs
  
  
  if not hasattr(paddle.Tensor, 'masked_fill'):
      logger.debug(
          "register user masked_fill to paddle.Tensor, remove this when fixed!")
      paddle.Tensor.masked_fill = masked_fill
  
  
  def masked_fill_(xs: paddle.Tensor,
                   mask: paddle.Tensor,
                   value: Union[float, int]) -> paddle.Tensor:
      assert is_broadcastable(xs.shape, mask.shape) is True
      bshape = paddle.broadcast_shape(xs.shape, mask.shape)
      mask = mask.broadcast_to(bshape)
      trues = paddle.ones_like(xs) * value
      ret = paddle.where(mask, trues, xs)
      paddle.assign(ret.detach(), output=xs)
      return xs
  
  
  if not hasattr(paddle.Tensor, 'masked_fill_'):
      logger.debug(
          "register user masked_fill_ to paddle.Tensor, remove this when fixed!")
      paddle.Tensor.masked_fill_ = masked_fill_
  
  
  def fill_(xs: paddle.Tensor, value: Union[float, int]) -> paddle.Tensor:
      val = paddle.full_like(xs, value)
      paddle.assign(val.detach(), output=xs)
      return xs
  
  
  if not hasattr(paddle.Tensor, 'fill_'):
      logger.debug(
          "register user fill_ to paddle.Tensor, remove this when fixed!")
      paddle.Tensor.fill_ = fill_
  
  
  def repeat(xs: paddle.Tensor, *size: Any) -> paddle.Tensor:
      return paddle.tile(xs, size)
  
  
  if not hasattr(paddle.Tensor, 'repeat'):
      logger.debug(
          "register user repeat to paddle.Tensor, remove this when fixed!")
      paddle.Tensor.repeat = repeat
  
  if not hasattr(paddle.Tensor, 'softmax'):
      logger.debug(
          "register user softmax to paddle.Tensor, remove this when fixed!")
      setattr(paddle.Tensor, 'softmax', paddle.nn.functional.softmax)
  
  if not hasattr(paddle.Tensor, 'sigmoid'):
      logger.debug(
          "register user sigmoid to paddle.Tensor, remove this when fixed!")
      setattr(paddle.Tensor, 'sigmoid', paddle.nn.functional.sigmoid)
  
  if not hasattr(paddle.Tensor, 'relu'):
      logger.debug("register user relu to paddle.Tensor, remove this when fixed!")
      setattr(paddle.Tensor, 'relu', paddle.nn.functional.relu)
  
  
  def type_as(x: paddle.Tensor, other: paddle.Tensor) -> paddle.Tensor:
      return x.astype(other.dtype)
  
  
  if not hasattr(paddle.Tensor, 'type_as'):
      logger.debug(
          "register user type_as to paddle.Tensor, remove this when fixed!")
      setattr(paddle.Tensor, 'type_as', type_as)
  
  
  def to(x: paddle.Tensor, *args, **kwargs) -> paddle.Tensor:
      assert len(args) == 1
      if isinstance(args[0], str):  # dtype
          return x.astype(args[0])
      elif isinstance(args[0], paddle.Tensor):  # Tensor
          return x.astype(args[0].dtype)
      else:  # Device
          return x
  
  
  if not hasattr(paddle.Tensor, 'to'):
      logger.debug("register user to to paddle.Tensor, remove this when fixed!")
      setattr(paddle.Tensor, 'to', to)
  
  
  def func_float(x: paddle.Tensor) -> paddle.Tensor:
      return x.astype(paddle.float)
  
  
  if not hasattr(paddle.Tensor, 'float'):
      logger.debug(
          "register user float to paddle.Tensor, remove this when fixed!")
      setattr(paddle.Tensor, 'float', func_float)
  
  
  def func_int(x: paddle.Tensor) -> paddle.Tensor:
      return x.astype(paddle.int)
  
  
  if not hasattr(paddle.Tensor, 'int'):
      logger.debug("register user int to paddle.Tensor, remove this when fixed!")
      setattr(paddle.Tensor, 'int', func_int)
  
  
  def tolist(x: paddle.Tensor) -> List[Any]:
      return x.numpy().tolist()
  
  
  if not hasattr(paddle.Tensor, 'tolist'):
      logger.debug(
          "register user tolist to paddle.Tensor, remove this when fixed!")
      setattr(paddle.Tensor, 'tolist', tolist)
  
  ########### hack paddle.nn #############
  from paddle.nn import Layer
  from typing import Optional
  from typing import Mapping
  from typing import Iterable
  from typing import Tuple
  from typing import Iterator
  from collections import OrderedDict, abc as container_abcs
  
  
  class LayerDict(paddle.nn.Layer):
      r"""Holds submodules in a dictionary.
  
      :class:`~paddle.nn.LayerDict` can be indexed like a regular Python dictionary,
      but modules it contains are properly registered, and will be visible by all
      :class:`~paddle.nn.Layer` methods.
  
      :class:`~paddle.nn.LayerDict` is an **ordered** dictionary that respects
  
      * the order of insertion, and
  
      * in :meth:`~paddle.nn.LayerDict.update`, the order of the merged
        ``OrderedDict``, ``dict`` (started from Python 3.6) or another
        :class:`~paddle.nn.LayerDict` (the argument to
        :meth:`~paddle.nn.LayerDict.update`).
  
      Note that :meth:`~paddle.nn.LayerDict.update` with other unordered mapping
      types (e.g., Python's plain ``dict`` before Python version 3.6) does not
      preserve the order of the merged mapping.
  
      Args:
          modules (iterable, optional): a mapping (dictionary) of (string: module)
              or an iterable of key-value pairs of type (string, module)
  
      Example::
  
          class MyModule(nn.Layer):
              def __init__(self):
                  super(MyModule, self).__init__()
                  self.choices = nn.LayerDict({
                          'conv': nn.Conv2d(10, 10, 3),
                          'pool': nn.MaxPool2d(3)
                  })
                  self.activations = nn.LayerDict([
                          ['lrelu', nn.LeakyReLU()],
                          ['prelu', nn.PReLU()]
                  ])
  
              def forward(self, x, choice, act):
                  x = self.choices[choice](x)
                  x = self.activations[act](x)
                  return x
      """
  
      def __init__(self, modules: Optional[Mapping[str, Layer]]=None) -> None:
          super(LayerDict, self).__init__()
          if modules is not None:
              self.update(modules)
  
      def __getitem__(self, key: str) -> Layer:
          return self._modules[key]
  
      def __setitem__(self, key: str, module: Layer) -> None:
          self.add_module(key, module)
  
      def __delitem__(self, key: str) -> None:
          del self._modules[key]
  
      def __len__(self) -> int:
          return len(self._modules)
  
      def __iter__(self) -> Iterator[str]:
          return iter(self._modules)
  
      def __contains__(self, key: str) -> bool:
          return key in self._modules
  
      def clear(self) -> None:
          """Remove all items from the LayerDict.
          """
          self._modules.clear()
  
      def pop(self, key: str) -> Layer:
          r"""Remove key from the LayerDict and return its module.
  
          Args:
              key (string): key to pop from the LayerDict
          """
          v = self[key]
          del self[key]
          return v
  
      def keys(self) -> Iterable[str]:
          r"""Return an iterable of the LayerDict keys.
          """
          return self._modules.keys()
  
      def items(self) -> Iterable[Tuple[str, Layer]]:
          r"""Return an iterable of the LayerDict key/value pairs.
          """
          return self._modules.items()
  
      def values(self) -> Iterable[Layer]:
          r"""Return an iterable of the LayerDict values.
          """
          return self._modules.values()
  
      def update(self, modules: Mapping[str, Layer]) -> None:
          r"""Update the :class:`~paddle.nn.LayerDict` with the key-value pairs from a
          mapping or an iterable, overwriting existing keys.
  
          .. note::
              If :attr:`modules` is an ``OrderedDict``, a :class:`~paddle.nn.LayerDict`, or
              an iterable of key-value pairs, the order of new elements in it is preserved.
  
          Args:
              modules (iterable): a mapping (dictionary) from string to :class:`~paddle.nn.Layer`,
                  or an iterable of key-value pairs of type (string, :class:`~paddle.nn.Layer`)
          """
          if not isinstance(modules, container_abcs.Iterable):
              raise TypeError("LayerDict.update should be called with an "
                              "iterable of key/value pairs, but got " + type(
                                  modules).__name__)
  
          if isinstance(modules,
                        (OrderedDict, LayerDict, container_abcs.Mapping)):
              for key, module in modules.items():
                  self[key] = module
          else:
              # modules here can be a list with two items
              for j, m in enumerate(modules):
                  if not isinstance(m, container_abcs.Iterable):
                      raise TypeError("LayerDict update sequence element "
                                      "#" + str(j) + " should be Iterable; is" +
                                      type(m).__name__)
                  if not len(m) == 2:
                      raise ValueError("LayerDict update sequence element "
                                       "#" + str(j) + " has length " + str(
                                           len(m)) + "; 2 is required")
                  # modules can be Mapping (what it's typed at), or a list: [(name1, module1), (name2, module2)]
                  # that's too cumbersome to type correctly with overloads, so we add an ignore here
                  self[m[0]] = m[1]  # type: ignore[assignment]
  
      # remove forward alltogether to fallback on Module's _forward_unimplemented
  
  
  if not hasattr(paddle.nn, 'LayerDict'):
      logger.debug(
          "register user LayerDict to paddle.nn, remove this when fixed!")
      setattr(paddle.nn, 'LayerDict', LayerDict)
  