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=True,
      coef=False,
      random_state=None,
      chunks=None,
  ):
      """
      Generate a random regression problem.
  
      The input set can either be well conditioned (by default) or have a low
      rank-fat tail singular profile. See
      :func:`sklearn.datasets.make_low_rank_matrix` for more details.
  
      This can be used to generate very large Dask arrays on a cluster of
      machines. When using Dask in distributed mode, the client machine
      only needs to allocate a single block's worth of data.
  
      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=True)
          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, RandomState instance or None (default)
          Determines random number generation for dataset creation. Pass an int
          for reproducible output across multiple function calls.
          See :term:`Glossary <random_state>`.
  
      chunks : int, tuple
          How to chunk the array. Must be one of the following forms:
          -   A blocksize like 1000.
          -   A blockshape like (1000, 1000).
          -   Explicit sizes of all blocks along all dimensions like
              ((1000, 1000, 500), (400, 400)).
  
      Returns
      -------
      X : Dask array of shape [n_samples, n_features]
          The input samples.
  
      y : Dask array of shape [n_samples] or [n_samples, n_targets]
          The output values.
  
      coef : 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.
      """
      chunks = da.core.normalize_chunks(chunks, (n_samples, n_features))
      _check_axis_partitioning(chunks, n_features)
  
      rng = sklearn.utils.check_random_state(random_state)
      return_coef = coef is True
  
      if chunks[1][0] != n_features:
          raise ValueError(
              "Can only generate arrays partitioned along the "
              "first axis. Specifying a larger chunksize for "
              "the second axis."
          )
      _, _, coef = sklearn.datasets.make_regression(
          n_samples=chunks[0][0],
          n_features=n_features,
          n_informative=n_informative,
          n_targets=n_targets,
          bias=bias,
          effective_rank=effective_rank,
          tail_strength=tail_strength,
          noise=noise,
          shuffle=shuffle,
          coef=True,  # hardcode here
          random_state=rng,
      )
      seed = da.random.random_state_data(1, random_state=rng)
      da_rng = da.random.RandomState(seed[0])
  
      X_big = da_rng.normal(
          size=(n_samples, n_features), chunks=(chunks[0], n_features)
      )
      y_big = da.dot(X_big, coef) + bias
  
      if noise > 0:
          y_big = y_big + da_rng.normal(
              scale=noise, size=y_big.shape, chunks=y_big.chunks
          )
  
      y_big = y_big.squeeze()
  
      if return_coef:
          return X_big, y_big, coef
      else:
          return X_big, y_big
  
file_path: dask-ml/dask_ml/datasets.py
imports: import numbers
  from datetime import timedelta
  import dask
  import dask.array
  import dask.dataframe
  import numpy
  import sklearn.datasets
  import sklearn.utils
  import dask_ml.utils
label_desc: Use image node_id 4 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, chunks) and returns: X_big,  y_big,  coef, X_big,  y_big