code: def _execute_map(cls, ctx, op: "ProximaBuilder"):
      mmap_path = ctx[op.inputs[0].key]
      out = op.outputs[0]
  
      data = np.memmap(
          mmap_path,
          dtype=op.array_dtype,
          mode="r",
          shape=op.array_shape,
      )
  
      proxima_type = get_proxima_type(op.array_dtype)
      offset = op.offset
  
      # holder
      with Timer() as timer:
          holder = proxima.IndexHolder(
              type=proxima_type, dimension=op.dimension, shallow=True
          )
          holder.mount(data, key_base=offset)
  
      logger.warning(f"Holder({op.key}) costs {timer.duration} seconds")
  
      # converter
      meta = proxima.IndexMeta(
          proxima_type,
          dimension=op.dimension,
          measure_name=op.distance_metric,
      )
      if op.index_converter is not None:
          with Timer() as timer:
              converter = proxima.IndexConverter(
                  name=op.index_converter,
                  meta=meta,
                  params=op.index_converter_params,
              )
              converter.train_and_transform(holder)
              holder = converter.result()
              meta = converter.meta()
  
          logger.warning(
              f"Converter({op.key}) costs {timer.duration} seconds"
          )
  
      # builder
      with Timer() as timer:
          builder = proxima.IndexBuilder(
              name=op.index_builder,
              meta=meta,
              params=op.index_builder_params,
          )
          builder = builder.train_and_build(holder)
  
      logger.warning(
          f"Builder({op.key}) costs {timer.duration} seconds"
      )
  
      # remove mmap file
      os.remove(mmap_path)
  
      # dumper
      with Timer() as timer:
          path = tempfile.mkstemp(prefix="proxima-", suffix=".index")[1]
          dumper = proxima.IndexDumper(name="FileDumper", path=path)
          builder.dump(dumper)
          dumper.close()
  
      logger.warning(f"Dumper({op.key}) costs {timer.duration} seconds")
  
      if op.index_path is None:
          ctx[out.key] = path
      else:
          # write to external file
          with Timer() as timer:
              fs = get_fs(op.index_path, op.storage_options)
              filename = f"proxima_{out.index[0]}_index"
              out_path = f'{op.index_path.rstrip("/")}/{filename}'
  
              def write_index():
                  with fs.open(out_path, "wb") as out_f:
                      with open(path, "rb") as in_f:
                          # 128M
                          chunk_bytes = 128 * 1024**2
                          while True:
                              data = in_f.read(chunk_bytes)
                              if data:
                                  out_f.write(data)
                              else:
                                  break
  
              # retry 3 times
              for _ in range(3):
                  try:
                      write_index()
                      break
                  except:  # noqa: E722  # nosec  # pylint: disable=bare-except
                      fs.delete(out_path)
                      continue
  
          logger.warning(
              f"WritingToVolume({op.key}), out path: {out_path}, "
              f"size {os.path.getsize(path)}, "
              f"costs {timer.duration} seconds "
              f"speed {round(os.path.getsize(path) / (1024 ** 2) / timer.duration, 2)} MB/s"
          )
  
          ctx[out.key] = filename
  
imports: import itertools
  import logging
  import os
  import pickle
  import tempfile
  import uuid
  import numpy
  from ....None import opcodes
  from ....None import tensor
  from ....lib.filesystem import get_fs
  from ....core import OutputType
  from ....core.context import get_context
  from ....core.operand import OperandStage
  from ....serialization.serializables import StringField, Int32Field, Int64Field, DictField, BytesField, TupleField, DataTypeField
  from ....utils import has_unknown_shape, Timer
  from ...operands import LearnOperand, LearnOperandMixin
  from ..core import proxima, get_proxima_type, validate_tensor, available_numpy_dtypes, rechunk_tensor, build_mmap_chunks
label_desc: Use image node_id 18 for calling the ProximaBuilder obj's underlying member method code with example usage: obj._execute_map(cls, ctx, op) without return types