code: def make_regression(
      n_samples=100,
      n_features=100,
      n_informative=10,
      n_targets=1,
      bias=0.0,
      effective_rank=None,
      tail_strength=0.5,
      noise=0.0,
      shuffle=False,
      coef=False,
      random_state=None,
      n_parts=1,
      n_samples_per_part=None,
      order="F",
      dtype="float32",
      client=None,
      use_full_low_rank=True,
  ):
      """
      Generate a random regression problem.
  
      The input set can either be well conditioned (by default) or have a low
      rank-fat tail singular profile.
  
      The output is generated by applying a (potentially biased) random linear
      regression model with "n_informative" nonzero regressors to the previously
      generated input and some gaussian centered noise with some adjustable
      scale.
  
      Parameters
      ----------
      n_samples : int, optional (default=100)
          The number of samples.
      n_features : int, optional (default=100)
          The number of features.
      n_informative : int, optional (default=10)
          The number of informative features, i.e., the number of features used
          to build the linear model used to generate the output.
      n_targets : int, optional (default=1)
          The number of regression targets, i.e., the dimension of the y output
          vector associated with a sample. By default, the output is a scalar.
      bias : float, optional (default=0.0)
          The bias term in the underlying linear model.
      effective_rank : int or None, optional (default=None)
          if not None:
              The approximate number of singular vectors required to explain most
              of the input data by linear combinations. Using this kind of
              singular spectrum in the input allows the generator to reproduce
              the correlations often observed in practice.
  
          if None:
              The input set is well conditioned, centered and gaussian with
              unit variance.
  
      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 if "effective_rank" is not None.
      noise : float, optional (default=0.0)
          The standard deviation of the gaussian noise applied to the output.
      shuffle : boolean, optional (default=False)
          Shuffle the samples and the features.
      coef : boolean, optional (default=False)
          If True, the coefficients of the underlying linear model are returned.
      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.
      order : str, optional (default='F')
          Row-major or Col-major
      dtype: str, optional (default='float32')
          dtype of generated data
      use_full_low_rank : boolean (default=True)
          Whether to use the entire dataset to generate the low rank matrix.
          If False, it creates a low rank covariance and uses the
          corresponding covariance to generate a multivariate normal
          distribution on the remaining chunks
  
      Returns
      -------
      X : Dask-CuPy array of shape [n_samples, n_features]
          The input samples.
      y : Dask-CuPy array of shape [n_samples] or [n_samples, n_targets]
          The output values.
      coef : Dask-CuPy array of shape [n_features] \
             or [n_features, n_targets], optional
          The coefficient of the underlying linear model. It is returned only if
          coef is True.
  
      Notes
      -----
      Known Performance Limitations:
       1. When `effective_rank` is set and `use_full_low_rank` is True, \
          we cannot generate order `F` by construction, and an explicit \
          transpose is performed on each part. This may cause memory to spike \
          (other parameters make order `F` by construction)
       2. When `n_targets > 1` and `order = 'F'` as above, we have to \
          explicitly transpose the `y` array. If `coef = True`, then we also \
          explicitly transpose the `ground_truth` array
       3. When `shuffle = True` and `order = F`, there are memory spikes to \
          shuffle the `F` order arrays
  
      .. note:: If out-of-memory errors are encountered in any of the above
          configurations, try increasing the `n_parts` parameter.
      """
  
      client = get_client(client=client)
  
      n_informative = min(n_features, n_informative)
      rs = _create_rs_generator(random_state)
  
      if n_samples_per_part is None:
          n_samples_per_part = max(1, int(n_samples / n_parts))
  
      data_chunksizes = [n_samples_per_part] * n_parts
  
      data_chunksizes[-1] += n_samples % n_parts
  
      data_chunksizes = tuple(data_chunksizes)
  
      if effective_rank is None:
          # Randomly generate a well conditioned input set
          if order == "F":
              X = _f_order_standard_normal(
                  client, rs, data_chunksizes, n_features, dtype
              )
  
          elif order == "C":
              X = rs.standard_normal(
                  (n_samples, n_features),
                  chunks=(data_chunksizes, -1),
                  dtype=dtype,
              )
  
      else:
          # Randomly generate a low rank, fat tail input set
          if use_full_low_rank:
              X = make_low_rank_matrix(
                  n_samples=n_samples,
                  n_features=n_features,
                  effective_rank=effective_rank,
                  tail_strength=tail_strength,
                  random_state=rs,
                  n_parts=n_parts,
                  n_samples_per_part=n_samples_per_part,
                  dtype=dtype,
              )
  
              X = X.rechunk({0: data_chunksizes, 1: -1})
          else:
              seed = int(rs.randint(n_samples).compute())
              covar = _make_low_rank_covariance(
                  client,
                  n_features,
                  effective_rank,
                  tail_strength,
                  seed,
                  n_parts,
                  n_samples_per_part,
                  dtype,
              )
              X = _data_from_multivariate_normal(
                  client, rs, covar, data_chunksizes, n_features, dtype
              )
  
          X = _convert_to_order(
              client, X, data_chunksizes, order, n_features, dtype
          )
  
      # Generate a ground truth model with only n_informative features being non
      # zeros (the other features are not correlated to y and should be ignored
      # by a sparsifying regularizers such as L1 or elastic net)
      ground_truth = 100.0 * rs.standard_normal(
          (n_informative, n_targets),
          chunks=(n_samples_per_part, -1),
          dtype=dtype,
      )
  
      y = da.dot(X[:, :n_informative], ground_truth) + bias
  
      if n_informative != n_features:
          zeroes = 0.0 * rs.standard_normal(
              (n_features - n_informative, n_targets), dtype=dtype
          )
          ground_truth = da.concatenate([ground_truth, zeroes], axis=0)
  
      ground_truth = ground_truth.rechunk(-1)
  
      # Add noise
      if noise > 0.0:
          y += rs.normal(scale=noise, size=y.shape, dtype=dtype)
  
      # Randomly permute samples and features
      if shuffle:
          features_indices = np.random.permutation(n_features)
          X, y = _shuffle(
              client,
              rs,
              X,
              y,
              data_chunksizes,
              n_features,
              features_indices,
              n_targets,
              dtype,
          )
  
          ground_truth = ground_truth[features_indices, :]
  
      y = da.squeeze(y)
  
      if order == "F" and n_targets > 1:
          y = _convert_to_order(
              client, y, y.chunks[0], order, n_targets, dtype
          )
          if coef:
              ground_truth = _convert_to_order(
                  client,
                  ground_truth,
                  ground_truth.chunks[0],
                  order,
                  n_targets,
                  dtype,
              )
  
      if coef:
          ground_truth = da.squeeze(ground_truth)
          return X, y, ground_truth
  
      else:
          return X, y
  
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 14 for calling a global function with example usage: make_regression(n_samples, n_features, n_informative, n_targets, bias, effective_rank, tail_strength, noise, shuffle, coef, random_state, n_parts, n_samples_per_part, order, dtype, client, use_full_low_rank) and returns: X,  y,  ground_truth, X,  y