code: def create(name="local"):
      """Creates a new KVStore.
  
      For single machine training, there are two commonly used types:
  
      ``local``: Copies all gradients to CPU memory and updates weights there.
  
      ``device``: Aggregates gradients and updates weights on GPUs. With this setting,
      the KVStore also attempts to use GPU peer-to-peer communication,
      potentially accelerating the communication.
  
      For distributed training, KVStore also supports a number of types:
  
      ``dist_sync``: Behaves similarly to ``local`` but with one major difference.
      With ``dist_sync``, batch-size now means the batch size used on each machine.
      So if there are ``n`` machines and we use batch size ``b``,
      then ``dist_sync`` behaves like ``local`` with batch size ``n * b``.
  
      ``dist_device_sync``: Identical to ``dist_sync`` with the difference similar
      to ``device`` vs ``local``.
  
      ``dist_async``: Performs asynchronous updates.
      The weights are updated whenever gradients are received from any machine.
      No two updates happen on the same weight at the same time. However, the order is not
      guaranteed.
  
      ``byteps``: Use byteps as broadcast/pushpull backend.
      This kind of kvstore doesn't store weights, thus there won't be optimizer in this kvstore server.
      Byteps doesn't support pure cpu training, so be sure to enable gpu training when using this kvstore.
  
      Parameters
      ----------
      name : {'local', 'device', 'nccl', 'dist_sync', 'dist_device_sync', 'dist_async', 'horovod', 'byteps'}
          The type of KVStore.
  
      Returns
      -------
      kv : KVStoreBase
          The created KVStore.
      """
      if not isinstance(name, string_types):
          raise TypeError("name must be a string")
      name = name.lower()
  
      # first lookup the registry
      if name in KVStoreBase.kv_registry:
          return KVStoreBase.kv_registry[name]()
      else:
          # fall back to the native kvstore implementation
          handle = KVStoreHandle()
          check_call(
              _LIB.MXKVStoreCreate(c_str(name), ctypes.byref(handle))
          )
          from .kvstore import KVStore
  
          kv = KVStore(handle)
          set_kvstore_handle(kv.handle)
          return kv
  
imports: from array import array
  import ctypes
  import warnings
  from ..ndarray import NDArray
  from ..base import _LIB, c_str_array, c_handle_array, c_array, c_array_buf, c_str
  from ..base import check_call, string_types
  from ..base import KVStoreHandle
  from ..profiler import set_kvstore_handle
label_desc: Use image node_id 3 for calling a global function with example usage: create(name) and returns: KVStoreBase, kv