code: def make_classification_df(
      n_samples=10000,
      response_rate=0.5,
      predictability=0.1,
      random_state=None,
      chunks=None,
      dates=None,
      **kwargs,
  ):
      """
      Uses the make_classification function to create a dask
      dataframe for testing.
  
      Parameters
      ----------
      n_samples : int, default is 10000
          number of observations to be generated
      response_rate : float between 0.0 and 0.5, default is 0.5
          percentage of sample to be response records max is 0.5
      predictability : float between 0.0 and 1.0, default is 0.1
          how hard is the response to predict (1.0 being easiest)
      random_state : int, default is None
          seed for reproducibility purposes
      chunks : int
          How to chunk the array. Must be one of the following forms:
          -   A blocksize like 1000.
      dates : tuple, optional, default is None
          tuple of start and end date objects to use for generating
          random dates in the date column
      **kwargs
          Other keyword arguments to pass to `sklearn.datasets.make_classification`
  
      Returns
      -------
      X : Dask DataFrame of shape [n_samples, n_features] or
          [n_samples, n_features + 1] when dates specified
          The input samples.
  
      y : Dask Series of shape [n_samples] or [n_samples, n_targets]
          The output values.
  
      """
      X_array, y_array = make_classification(
          n_samples=n_samples,
          flip_y=(1 - predictability),
          random_state=random_state,
          weights=[(1 - response_rate), response_rate],
          chunks=chunks,
          **kwargs,
      )
  
      # merge into a dataframe and name columns
      columns = ["var" + str(i) for i in range(np.shape(X_array)[1])]
      X_df = dd.from_dask_array(X_array, columns=columns)
      y_series = dd.from_dask_array(
          y_array, columns="target", index=X_df.index
      )
  
      if dates:
          # create a date variable
          np.random.seed(random_state)
          X_df = dd.concat(
              [
                  X_df,
                  dd.from_array(
                      np.array([random_date(*dates)] * len(X_df)),
                      chunksize=chunks,
                      columns=["date"],
                  ),
              ],
              axis=1,
          )
  
      return X_df, y_series
  
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 7 for calling a global function with example usage: make_classification_df(n_samples, response_rate, predictability, random_state, chunks, dates) and returns: X_df,  y_series