code: def execute_map(cls, ctx, op):
      out = op.outputs[0]
      x = ctx[op.input.key]
      axes, seeds, reduce_sizes = op.axes, op.seeds, op.reduce_sizes
      if 1 in set(op.reduce_sizes):
          # if chunk size on shuffle axis == 0
          inds = [slice(None) for _ in range(x.ndim)]
          extra_axes, extra_seeds, extra_reduce_sizes = [], [], []
          for ax, seed, reduce_size in zip(axes, seeds, reduce_sizes):
              rs = np.random.RandomState(seed)
              if reduce_size == 1:
                  inds[ax] = rs.permutation(np.arange(x.shape[ax]))
              else:
                  extra_axes.append(ax)
                  extra_seeds.append(seed)
                  extra_reduce_sizes.append(reduce_size)
          # for the reduce == 1
          # do shuffle on the map phase
          x = _safe_slice(x, tuple(inds), op.output_types[0])
          axes, seeds, reduce_sizes = (
              extra_axes,
              extra_seeds,
              extra_reduce_sizes,
          )
  
      to_hash_inds = []
      for ax, seed, reduce_size in zip(axes, seeds, reduce_sizes):
          rs = np.random.RandomState(seed)
          to_hash_inds.append(rs.randint(reduce_size, size=x.shape[ax]))
  
      for reduce_index in itertools.product(
          *(range(rs) for rs in reduce_sizes)
      ):
          index = list(out.index)
          for ax, ind in zip(axes, reduce_index):
              index[ax] = ind
          selected = x
          for ax, to_hash_ind in zip(axes, to_hash_inds):
              slc = (slice(None),) * ax + (to_hash_ind == index[ax],)
              selected = _safe_slice(selected, slc, op.output_types[0])
          ctx[out.key, tuple(index)] = (
              ctx.get_current_chunk().index,
              selected,
          )
  
imports: import itertools
  from collections import defaultdict
  from collections.abc import Iterable
  from functools import reduce
  import numpy
  import pandas
  from ...None import opcodes
  from ...core import get_output_types, recursive_tile
  from ...core.operand import OperandStage, MapReduceOperand
  from ...dataframe.utils import parse_index
  from ...lib import sparse
  from ...serialization.serializables import FieldTypes, TupleField, KeyField
  from ...tensor.utils import validate_axis, check_random_state, gen_random_seeds, decide_unify_split
  from ...tensor.array_utils import get_array_module
  from ...utils import tokenize, lazy_import, has_unknown_shape
  from ...core import ExecutableTuple
  from ..operands import LearnOperandMixin, OutputType, LearnShuffleProxy
  from ..utils import convert_to_tensor_or_dataframe
label_desc: Use image node_id 16 for calling the LearnShuffle obj's underlying member method code with example usage: obj.execute_map(cls, ctx, op) without return types