code: def execute(cls, ctx, op):
      (x,), device_id, xp = as_same_device(
          [ctx[inp.key] for inp in op.inputs],
          device=op.device,
          ret_extra=True,
      )
      axis = op.axis
      return_norm = op.return_norm
      norm = op.norm
      outs = op.outputs
  
      with device(device_id):
          if (
              device_id < 0
              and op.use_sklearn
              and sklearn_normalize is not None
          ):
              # no GPU
              try:
                  if xp is sparse:
                      if axis == 0:
                          xm = x.raw.tocsc()
                      else:
                          xm = x.raw
                  else:
                      xm = x
                  ret = sklearn_normalize(
                      xm, norm=norm, axis=axis, return_norm=return_norm
                  )
                  normed = None
                  if return_norm:
                      ret, normed = ret
                  if issparse(ret):
                      ret = sparse.SparseNDArray(ret)
                  ctx[outs[0].key] = ret
                  if normed is not None:
                      ctx[outs[1].key] = normed
                  return
              except NotImplementedError:
                  pass
  
          # fall back
          if axis == 0:
              x = x.T
  
          if norm == "l1":
              norms = xp.abs(x).sum(axis=1)
          elif norm == "l2":
              norms = xp.sqrt((x**2).sum(axis=1))
          else:
              norms = xp.max(x, axis=1)
              if issparse(norms):
                  norms = norms.toarray()
          norms[norms == 0.0] = 1.0
          x = x / norms[:, np.newaxis]
  
          if axis == 0:
              x = x.T
  
          ctx[outs[0].key] = x
          if return_norm:
              ctx[outs[1].key] = norms
  
imports: import numpy
  from ...None import opcodes
  from ...core import ExecutableTuple, recursive_tile
  from ...serialization.serializables import KeyField, StringField, Int32Field, BoolField
  from ...tensor.operands import TensorOperand, TensorOperandMixin
  from ...tensor.core import TensorOrder
  from ...tensor.array_utils import as_same_device, device, sparse, issparse
  from ...None import tensor
  from ..utils import check_array
label_desc: Use image node_id 14 for calling the TensorNormalize obj's underlying member method code with example usage: obj.execute(cls, ctx, op) without return types