def identity(inputs, **kwargs): """Return a tensor copied from the input. Examples: ```python # Copy ``x`` to ``y`` x = dragon.zeros(shape=(2, 3)) y = dragon.identity(x) # ``x`` != ``y`` x += 1 print(x) print(y) ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Identity', inputs) return OpLib.add('Identity', inputs, **kwargs)
def less_equal(inputs, **kwargs): r"""Compute the element-wise less-equal comparison. .. math:: \text{out} = (\text{input1} <= \text{input2}) Examples: ```python a = dragon.constant(2) b = dragon.constant(3) c = dragon.constant(3) print(dragon.math.less_equal([a, b])) print(dragon.math.less_equal([b, c])) ``` Parameters ---------- inputs : Sequence[dragon.Tensor] The input1 and input2 tensor. Returns ------- dragon.Tensor The output tensor. """ inputs = constant_ops.remove_scalars(inputs) if context.executing_eagerly(): return OpLib.execute('LessEqual', inputs) return OpLib.add('LessEqual', inputs, **kwargs)
def logical_and(inputs, **kwargs): r"""Compute the element-wise AND logical operation. .. math:: \text{out} = \text{input1} \mathbin{\&} \text{input2} Examples: ```python a = dragon.constant([False, True, False, True]) b = dragon.constant([False, True, True, False]) c = dragon.constant([0, 1, 0, 2]) d = dragon.constant([0, 3, 4, 0]) print(dragon.math.logical_and([a, b])) # [False, True, False, False] print(dragon.math.logical_and([c, d])) # [False, True, False, False] ``` Parameters ---------- inputs : Sequence[dragon.Tensor] The input1 and input2 tensor. Returns ------- dragon.Tensor The output tensor. """ inputs = constant_ops.remove_scalars(inputs) if context.executing_eagerly(): return OpLib.execute('And', inputs) return OpLib.add('And', inputs, **kwargs)
def exp(inputs, **kwargs): r"""Compute the exponential of input. .. math:: \text{out} = \exp(\text{input}) Examples: ```python x = dragon.constant([1., 2., 3.]) print(dragon.math.exp(x)) # [2.71828183, 7.3890561, 20.08553692] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Exp', inputs) return OpLib.add('Exp', inputs, **kwargs)
def invert(inputs, **kwargs): r"""Invert each bit of input. .. math:: \text{out} = \,\,\sim \text{input} Examples: ```python # Typically, ``x`` is a bool tensor print(dragon.bitwise.invert(dragon.constant([0, 1], 'bool'))) # [True, False] # Otherwise, integral types are required (unsigned or signed) # 00001101 (13) -> 11110010 (?) print(dragon.bitwise.invert(dragon.constant(13, 'uint8'))) # 242 print(dragon.bitwise.invert(dragon.constant(13, 'int8'))) # -14 ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('BitwiseNot', inputs) return OpLib.add('BitwiseNot', inputs, **kwargs)
def ceil(inputs, **kwargs): r"""Compute the smallest integer not less than input. .. math:: \text{out} = \lceil \text{input} \rceil Examples: ```python x = dragon.constant([1.4, 1.7, 2.0]) print(dragon.math.ceil(x)) # [2., 2., 2.] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Ceil', inputs) return OpLib.add('Ceil', inputs, **kwargs)
def cos(inputs, **kwargs): r"""Compute the cos of input. .. math:: \text{out} = \cos(\text{input}) Examples: ```python x = dragon.constant([0., math.pi]) print(dragon.math.cos(x)) # [1., -1.] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Cos', inputs) return OpLib.add('Cos', inputs, **kwargs)
def pow(inputs, **kwargs): r"""Compute the power of input. .. math:: \text{out} = \text{input}^{\text{exponent}} The two inputs should be broadcast to each other: ```python x = dragon.fill(shape=(1, 2), value=2) print(dragon.math.pow([x, x])) # [[4, 4]] print(dragon.math.pow([x, 3])) # [[8, 8]] print(dragon.math.pow([3, x])) # [[9, 9]] ``` Parameters ---------- inputs : Sequence[dragon.Tensor] The input and exponent tensor. Returns ------- dragon.Tensor The output tensor. """ inputs = constant_ops.remove_scalars(inputs) if context.executing_eagerly(): return OpLib.execute('Pow', inputs) return OpLib.add('Pow', inputs, **kwargs)
def reciprocal(inputs, **kwargs): r"""Compute the reciprocal of input. .. math:: \text{out} = \frac{1}{\text{input}} Examples: ```python x = dragon.constant([0., 1., 2.]) print(dragon.math.reciprocal(x)) # [inf, 1., 0.5] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Reciprocal', inputs) return OpLib.add('Reciprocal', inputs, **kwargs)
def accuracy(inputs, axis=-1, top_k=1, ignore_index=None, **kwargs): """Compute the top-k accuracy. Parameters ---------- inputs : Sequence[dragon.Tensor] The tensor ``logit`` and ``label``. axis : int, optional, default=-1 The axis to reduce, can be negative. top_k : int, optional, default=1 The top-k accuracy to compute. ignore_index : int, optional The ignored value of target. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute( 'Accuracy', inputs, axis=axis, top_k=top_k, ignore_index=ignore_index) return OpLib.add('Accuracy', inputs, axis=axis, top_k=top_k, ignore_index=ignore_index, **kwargs)
def argmin(inputs, axis=0, keepdims=False, **kwargs): """Compute the index of minimum elements along the given axis. :attr:`axis` could be negative: ```python # A negative axis is the last-k axis x = dragon.constant([[1, 2, 3], [4, 5, 6]]) print(dragon.math.argmin(x, axis=1)) print(dragon.math.argmin(x, axis=-1)) # Equivalent ``` Parameters ---------- inputs : dragon.Tensor The input tensor. axis : int, optional, default=0 The axis to reduce. keepdims : bool, optional, default=False Keep the reduced dimension or not. Returns ------- dragon.Tensor The index of minimum elements. """ if context.executing_eagerly(): return OpLib.execute('ArgMin', inputs, axis=axis, keepdims=keepdims) return OpLib.add('ArgMin', inputs, axis=axis, keepdims=keepdims)
def tile(inputs, repeats, **kwargs): """Repeat elements along each axis of input. Examples: ```python x = dragon.constant([[1, 2], [3, 4]]) print(dragon.tile(x, repeats=(1, 2))) # [[1, 2, 1, 2], [3, 4, 3, 4]] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. repeats : Union[Sequence[int], dragon.Tensor]] The repetition for each axis. Returns ------- dragon.Tensor The output tensor. """ args = OpSchema.parse_args(locals()) if context.executing_eagerly(): return OpLib.execute( 'Tile', inputs, ndim=len(args['repeats']), repeats=args['repeats']) return OpLib.add('Tile', **args)
def shape(inputs, **kwargs): """Return the shape of input. Examples: ```python x = dragon.ones((2, 3)) print(x.shape) # Return a sequence print(dragon.shape(x)) # Return a tensor ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The tensor shape. """ if context.executing_eagerly(): return OpLib.execute('Shape', inputs) return OpLib.add('Shape', inputs, **kwargs)
def reverse(inputs, axis, **kwargs): """Reverse elements along the given axis. :attr:`axis` could be negative: ```python x = dragon.constant([[1, 2, 3], [4, 5, 6]]) # A negative axis is the last-k axis print(dragon.reverse(x, axis=1)) # [[3, 2, 1], [6, 5, 4]] print(dragon.reverse(x, axis=-1)) # Equivalent # Also, axis could be a sequence of integers print(dragon.reverse(x, axis=(0, 1))) # [[6, 5, 4], [3, 2, 1]] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. axis : Union[int, Sequence[int]] The axis to reverse. Returns ------- dragon.Tensor The output tensor. """ axes = nest.flatten(axis) if axis is not None else axis if context.executing_eagerly(): return OpLib.execute('Reverse', inputs, axes=axes) return OpLib.add('Reverse', inputs, axes=axes, **kwargs)
def bitwise_xor(inputs, **kwargs): r"""Compute the element-wise XOR bitwise operation. .. math:: \text{out} = \text{input1} \oplus \text{input2} Examples: ```python a = dragon.constant([0, -1, 2, -3, 4]) b = dragon.constant([-4, 3, -2, 1, 0]) print(dragon.bitwise.bitwise_xor([a, b])) # [-4, -4, -4, -4, 4] ``` Parameters ---------- inputs : Sequence[dragon.Tensor] The input1 and input2 tensor. Returns ------- dragon.Tensor The output tensor. """ inputs = constant_ops.remove_scalars(inputs) if context.executing_eagerly(): return OpLib.execute('BitwiseXor', inputs) return OpLib.add('BitwiseXor', inputs, **kwargs)
def round(inputs, **kwargs): r"""Compute the nearest integer of input. .. math:: \text{out} = \lfloor \text{input} \rceil Examples: ```python x = dragon.constant([0.9, 1.4, 1.9]) print(dragon.math.round(x)) # [1., 1., 2.] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Round', inputs) return OpLib.add('Round', inputs, **kwargs)
def cast(inputs, dtype, copy=True, **kwargs): """Convert the data type of input. Examples: ```python x = dragon.constant([1, 2, 3], dtype='int64') print(dragon.cast(x, dtype='float32')) ``` Parameters ---------- inputs : dragon.Tensor The input tensor. dtype : str The data type to convert to. copy : bool, optional, default=True Return a new tensor or call in-place. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Cast', inputs, outputs=[None] if copy else inputs, dtype=dtype) return OpLib.add('Cast', inputs, dtype=dtype, **kwargs)
def rsqrt(inputs, **kwargs): r"""Compute the reciprocal square root of input. .. math:: \text{out} = \frac{1}{\sqrt{\text{input}}} Examples: ```python x = dragon.constant([0., 4., 16.]) print(dragon.math.rsqrt(x)) # [inf, 0.5, 0.25] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Rsqrt', inputs) return OpLib.add('Rsqrt', inputs, **kwargs)
def clip(inputs, low=None, high=None, **kwargs): r"""Compute the clipped input according to the given bounds. .. math:: \text{out} = \min(\max(\text{input}, \text{low}), \text{high}) Examples: ```python x = dragon.constant([0, 1, 2, 3]) print(dragon.math.clip(x, low=1)) # [1, 1, 2, 3] print(dragon.math.clip(x, high=2)) # [0, 1, 2, 2] print(dragon.math.clip(x, low=1, high=2)) # [1, 1, 2, 2] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. low : number, optional The value to :math:`\text{low}`. high : number, optional The value to :math:`\text{high}`. Returns ------- dragon.Tensor The output tensor. """ low = float(low) if low is not None else None high = float(high) if high is not None else None if context.executing_eagerly(): return OpLib.execute('Clip', inputs, low=low, high=high) return OpLib.add('Clip', inputs, low=low, high=high, **kwargs)
def sign(inputs, **kwargs): r"""Compute the sign indication of input. .. math:: \text{out}_[i] = \begin{cases} -1, & \text{ if } \text{input}_{i} < 0 \\ 0, & \text{ if } \text{input}_{i} = 0 \\ 1, & \text{ if } \text{input}_{i} > 0 \end{cases} Examples: ```python x = dragon.constant([-2, 0, 2]) print(dragon.math.sign(x)) # [-1, 0, 1] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Sign', inputs) return OpLib.add('Sign', inputs, **kwargs)
def add(inputs, **kwargs): r"""Compute the element-wise addition. .. math:: \text{out} = \text{input1} + \text{input2} Examples: ```python a = dragon.constant(1) b = dragon.constant(2) print(dragon.math.add([a, b])) print(a + b) # Equivalent operation ``` Parameters ---------- inputs : Sequence[dragon.Tensor] The input1 and input2 tensor. Returns ------- dragon.Tensor The output tensor. """ inputs = constant_ops.remove_scalars(inputs) if context.executing_eagerly(): return OpLib.execute('Add', inputs) return OpLib.add('Add', inputs, **kwargs)
def sqrt(inputs, **kwargs): r"""Compute the square root of input. .. math:: \text{out} = \sqrt{\text{input}} Examples: ```python x = dragon.constant([4., 9., 16.]) print(dragon.math.sqrt(x)) # [2., 3., 4.] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Sqrt', inputs) return OpLib.add('Sqrt', inputs, **kwargs)
def floor(inputs, **kwargs): r"""Compute the largest integer not greater than input. .. math:: \text{out} = \lfloor \text{input} \rfloor Examples: ```python x = dragon.constant([0.9, 1.4, 1.9]) print(dragon.math.floor(x)) # [0., 1., 1.] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Floor', inputs) return OpLib.add('Floor', inputs, **kwargs)
def square(inputs, **kwargs): r"""Compute the square of input. .. math:: \text{out} = \text{input}^{2} Examples: ```python x = dragon.constant([2, 3, 4]) print(dragon.math.square(x)) ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Square', inputs) return OpLib.add('Square', inputs, **kwargs)
def is_nan(inputs, **kwargs): r"""Check if the elements of input are NaN. .. math:: \text{out} = \text{isnan}(\text{input}) Examples: ```python x = dragon.constant([0., 1., float('nan')]) print(dragon.math.is_nan(x)) # [False, False, True] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('IsNaN', inputs) return OpLib.add('IsNaN', inputs, **kwargs)
def atan2(inputs, **kwargs): r"""Compute the element-wise arc-tangent of two arguments. .. math:: \text{out} = \text{arctan}(\frac{\text{input1}}{\text{input2}}) Examples: ```python y = dragon.constant(1) x = dragon.constant(2) print(dragon.math.atan2([y, x])) # 0.46364761 ``` Parameters ---------- inputs : Sequence[dragon.Tensor] The input1 and input2 tensor. Returns ------- dragon.Tensor The output tensor. """ inputs = constant_ops.remove_scalars(inputs) if context.executing_eagerly(): return OpLib.execute('Atan2', inputs) return OpLib.add('Atan2', inputs, **kwargs)
def log(inputs, **kwargs): r"""Compute the logarithm of input. .. math:: \text{out} = \log(\text{input}) Examples: ```python x = dragon.constant([1., 2., 3.]) print(dragon.math.log(x)) # [0., 0.69314718, 1.09861229] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Log', inputs) return OpLib.add('Log', inputs, **kwargs)
def abs(inputs, **kwargs): r"""Compute the absolute value of input. .. math:: \text{out} = \left| \text{input} \right| Examples: ```python x = dragon.constant([-1, 0, 1]) print(dragon.math.abs(x)) # [1, 0, 1] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Abs', inputs) return OpLib.add('Abs', inputs, **kwargs)
def logical_not(inputs, **kwargs): r"""Compute the element-wise NOT logical operation. .. math:: \text{out} = \,\,\sim \text{input} Examples: ```python a = dragon.constant([False, True, True]) b = dragon.constant([0, 1, 2]) print(dragon.math.logical_not(a)) # [True, False, False] print(dragon.math.logical_not(b)) # [True, False, False] ``` Parameters ---------- inputs : dragon.Tensor The input tensor. Returns ------- dragon.Tensor The output tensor. """ if context.executing_eagerly(): return OpLib.execute('Not', inputs) return OpLib.add('Not', inputs, **kwargs)
def assign(inputs, starts=None, sizes=None, copy=False, **kwargs): r"""Assign the value to input. .. math:: \text{input}[\text{start}:\text{start} + \text{size}, ...] = \text{value} Parameters ---------- inputs : Sequence[dragon.Tensor] The input and value tensor. starts : Union[Sequence[int], dragon.Tensor]], optional The start location for each dimension. sizes : Union[Sequence[int], dragon.Tensor]], optional The number of elements from start. copy : bool, optional, default=False Return a new tensor or call in-place. Returns ------- dragon.Tensor The output tensor. """ args = OpSchema.parse_args(locals()) inputs = constant_ops.remove_scalars(inputs) if context.executing_eagerly(): starts = args['starts'] if starts is not None else [0] sizes = args['sizes'] if sizes is not None else [-1] return OpLib.execute( 'Assign', inputs, outputs=[None if copy else inputs[0]], ndim=len(starts), starts=starts, sizes=sizes) return OpLib.add('Assign', **args)