code: def make_low_rank_matrix(
      n_samples=100,
      n_features=100,
      effective_rank=10,
      tail_strength=0.5,
      random_state=None,
      n_parts=1,
      n_samples_per_part=None,
      dtype="float32",
  ):
      """ Generate a mostly low rank matrix with bell-shaped singular values
  
      Parameters
      ----------
      n_samples : int, optional (default=100)
          The number of samples.
      n_features : int, optional (default=100)
          The number of features.
      effective_rank : int, optional (default=10)
          The approximate number of singular vectors required to explain most of
          the data by linear combinations.
      tail_strength : float between 0.0 and 1.0, optional (default=0.5)
          The relative importance of the fat noisy tail of the singular values
          profile.
      random_state : int, CuPy RandomState instance, Dask RandomState instance \
                     or None (default)
          Determines random number generation for dataset creation. Pass an int
          for reproducible output across multiple function calls.
      n_parts : int, optional (default=1)
          The number of parts of work.
      dtype: str, optional (default='float32')
          dtype of generated data
  
      Returns
      -------
      X : Dask-CuPy array of shape [n_samples, n_features]
          The matrix.
  
      """
  
      rs = _create_rs_generator(random_state)
      n = min(n_samples, n_features)
  
      # Random (ortho normal) vectors
      m1 = rs.standard_normal(
          (n_samples, n),
          chunks=(_generate_chunks_for_qr(n_samples, n, n_parts), -1),
          dtype=dtype,
      )
      u, _ = da.linalg.qr(m1)
  
      m2 = rs.standard_normal(
          (n, n_features),
          chunks=(-1, _generate_chunks_for_qr(n_features, n, n_parts)),
          dtype=dtype,
      )
      v, _ = da.linalg.qr(m2)
  
      # For final multiplication
      if n_samples_per_part is None:
          n_samples_per_part = max(1, int(n_samples / n_parts))
      u = u.rechunk({0: n_samples_per_part, 1: -1})
      v = v.rechunk({0: n_samples_per_part, 1: -1})
  
      local_s = _generate_singular_values(
          n, effective_rank, tail_strength, n_samples_per_part
      )
      s = da.from_array(local_s, chunks=(int(n_samples_per_part),))
  
      u *= s
      return da.dot(u, v)
  
imports: from cuml.dask.common.utils import get_client
  from cuml.dask.common.input_utils import DistributedDataHandler
  from cuml.common import with_cupy_rmm
  from cuml.dask.datasets.utils import _create_delayed
  from cuml.dask.datasets.utils import _get_labels
  from cuml.dask.datasets.utils import _get_X
  from cuml.internals.safe_imports import gpu_only_import
  import dask.array
  from cuml.internals.safe_imports import cpu_only_import
label_desc: Use image node_id 13 for calling a global function with example usage: make_low_rank_matrix(n_samples, n_features, effective_rank, tail_strength, random_state, n_parts, n_samples_per_part, dtype) and returns: da