code: def _execute_map(cls, ctx, op: "ProximaSearcher"):
      if op.download_index:
          cls._execute_download(ctx, op)
          return
  
      inp = ctx[op.tensor.key]
      index_path = ctx[op.inputs[-1].key]
  
      with Timer() as timer:
          flow = proxima.IndexFlow(
              container_name="MMapFileContainer",
              container_params={},
              searcher_name=op.index_searcher,
              searcher_params=op.index_searcher_params,
              measure_name="",
              measure_params={},
              reformer_name=op.index_reformer,
              reformer_params=op.index_reformer_params,
          )
  
          flow.load(index_path)
          vecs = np.ascontiguousarray(inp)
  
      logger.warning(
          f"LoadIndex({op.key})  index path: {index_path}  costs {timer.duration} seconds"
      )
      logger.warning(
          f"threads count:{op.threads}  vecs count:{len(vecs)}"
      )
  
      with Timer() as timer:
          batch = 10000
          s_idx = 0
          e_idx = min(s_idx + batch, len(vecs))
          result_pks, result_distances = None, None
          while s_idx < len(vecs):
              with Timer() as timer_s:
                  tp = get_proxima_type(vecs.dtype)
                  (
                      result_pks_b,
                      result_distances_b,
                  ) = proxima.IndexUtility.ann_search(
                      searcher=flow,
                      type=tp,
                      query=vecs[s_idx:e_idx],
                      topk=op.topk,
                      threads=op.threads,
                  )
                  if result_pks is None:
                      result_pks = np.asarray(result_pks_b)
                      result_distances = np.asarray(result_distances_b)
                  else:
                      result_pks = np.concatenate(
                          (result_pks, np.asarray(result_pks_b))
                      )
                      result_distances = np.concatenate(
                          (
                              result_distances,
                              np.asarray(result_distances_b),
                          )
                      )
  
                  s_idx = e_idx
                  e_idx = min(s_idx + batch, len(vecs))
              logger.warning(
                  f"Search({op.key}) count {s_idx}/{len(vecs)}:{round(s_idx * 100 / len(vecs), 2)}%"
                  f" costs {round(timer_s.duration, 2)} seconds"
              )
      logger.warning(f"Search({op.key}) costs {timer.duration} seconds")
  
      ctx[op.outputs[0].key] = np.asarray(result_pks)
      ctx[op.outputs[1].key] = np.asarray(result_distances)
  
imports: import itertools
  import logging
  import os
  import pickle
  import random
  from hashlib import md5
  from collections import defaultdict
  import numpy
  from ....None import opcodes
  from ....None import tensor
  from ....config import options
  from ....core import ENTITY_TYPE, OutputType, recursive_tile
  from ....core.context import get_context
  from ....core.operand import OperandStage
  from ....lib.filesystem import get_fs, FileSystem
  from ....serialization.serializables import KeyField, StringField, Int32Field, Int64Field, DictField, AnyField, BytesField, BoolField
  from ....tensor.core import TensorOrder
  from ....utils import has_unknown_shape, Timer, ceildiv
  from ...operands import LearnOperand, LearnOperandMixin
  from ..core import proxima, validate_tensor, get_proxima_type
label_desc: Use image node_id 21 for calling the ProximaSearcher obj's underlying member method code with example usage: obj._execute_map(cls, ctx, op) without return types