code: def zeros(
      shape,
      dtype=None,
      chunk_size=None,
      gpu=None,
      sparse=False,
      order="C",
  ):
      """
      Return a new tensor of given shape and type, filled with zeros.
  
      Parameters
      ----------
      shape : int or sequence of ints
          Shape of the new tensor, e.g., ``(2, 3)`` or ``2``.
      dtype : data-type, optional
          The desired data-type for the array, e.g., `mt.int8`.  Default is
          `mt.float64`.
      chunk_size : int or tuple of int or tuple of ints, optional
          Desired chunk size on each dimension
      gpu : bool, optional
          Allocate the tensor on GPU if True, False as default
      sparse: bool, optional
          Create sparse tensor if True, False as default
      order : {'C', 'F'}, optional, default: 'C'
          Whether to store multi-dimensional data in row-major
          (C-style) or column-major (Fortran-style) order in
          memory.
  
      Returns
      -------
      out : Tensor
          Tensor of zeros with the given shape, dtype, and order.
  
      See Also
      --------
      zeros_like : Return a tensor of zeros with shape and type of input.
      ones_like : Return a tensor of ones with shape and type of input.
      empty_like : Return a empty tensor with shape and type of input.
      ones : Return a new tensor setting values to one.
      empty : Return a new uninitialized tensor.
  
      Examples
      --------
      >>> import mars.tensor as mt
      >>> mt.zeros(5).execute()
      array([ 0.,  0.,  0.,  0.,  0.])
  
      >>> mt.zeros((5,), dtype=int).execute()
      array([0, 0, 0, 0, 0])
  
      >>> mt.zeros((2, 1)).execute()
      array([[ 0.],
             [ 0.]])
  
      >>> s = (2,2)
      >>> mt.zeros(s).execute()
      array([[ 0.,  0.],
             [ 0.,  0.]])
  
      >>> mt.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]).execute() # custom dtype
      array([(0, 0), (0, 0)],
            dtype=[('x', '<i4'), ('y', '<i4')])
      """
      tensor_order = get_order(
          order,
          None,
          available_options="CF",
          err_msg="only 'C' or 'F' order is permitted",
      )
      dtype = np.dtype(dtype or "f8")
      op = TensorZeros(
          dtype=dtype,
          shape=shape,
          chunk_size=chunk_size,
          gpu=gpu,
          sparse=sparse,
          order=order,
      )
      return op(shape, chunk_size=chunk_size, order=tensor_order)
  
imports: import numpy
  from ...None import opcodes
  from ...serialization.serializables import FieldTypes, AnyField, TupleField, KeyField, StringField
  from ...lib import sparse
  from ...lib.sparse.core import get_sparse_module, get_array_module, naked
  from ..array_utils import create_array
  from ..utils import get_order
  from .core import TensorNoInput, TensorLike
  from .array import tensor
label_desc: Use image node_id 1 for calling a global function with example usage: zeros(shape, dtype, chunk_size, gpu, sparse, order) and returns: op