class_docstr: Same as :class:`MapData`, but start processes to run the mapping function,
  and communicate with ZeroMQ pipe.
  
  The semantics of this class is **identical** to :class:`MapData` except for the ordering.
  Processes run in parallel and can take different time to run the
  mapping function. Therefore the order of datapoints won't be preserved.
  
  When ``strict=True``, ``MultiProcessMapData(df, ...)``
  is guaranteed to produce the exact set of data as ``MapData(df, ...)``,
  if both are iterated until ``StopIteration``. But the produced data will have different ordering.
  The behavior of strict mode is undefined if the given dataflow ``df`` is infinite.
  
  When ``strict=False``, the data that's produced by ``MultiProcessMapData(df, ...)``
  is a reordering of the data produced by ``RepeatedData(MapData(df, ...), -1)``.
  In other words, first pass of ``MultiProcessMapData.__iter__`` may contain
  datapoints from the second pass of ``df.__iter__``.
code: def reset_state(self):
      _MultiProcessZMQDataFlow.reset_state(self)
      _ParallelMapData.reset_state(self)
      self._guard = DataFlowReentrantGuard()
  
      self.context = zmq.Context()
      self.socket = self.context.socket(zmq.DEALER)
      self.socket.set_hwm(self._buffer_size * 2)
      pipename = _get_pipe_name("dataflow-map")
      _bind_guard(self.socket, pipename)
  
      self._proc_ids = [
          "{}".format(k).encode("utf-8") for k in range(self.num_proc)
      ]
      worker_hwm = int(self._buffer_size * 2 // self.num_proc)
      self._procs = [
          self._create_worker(self._proc_ids[k], pipename, worker_hwm)
          for k in range(self.num_proc)
      ]
  
      self._start_processes()
      self._fill_buffer()
  
imports: import copy
  import ctypes
  import multiprocessing
  import numpy
  import threading
  import zmq
  from six.moves import queue
  from ..utils.concurrency import StoppableThread, enable_death_signal
  from ..utils.serialize import dumps_once, loads_once
  from .base import DataFlow, DataFlowReentrantGuard, ProxyDataFlow
  from .common import RepeatedData, BatchData
  from .parallel import _bind_guard, _get_pipe_name, _MultiProcessZMQDataFlow, _repeat_iter, _zmq_catch_error
label_desc: Use image node_id 3 for calling the MultiProcessMapDataZMQ obj's underlying member method code with example usage: obj.reset_state() without return types