Is this shuffle=True needed? There's made a modification above where shuffle=True is hard-coded.

This method warns when given a dataframe and shuffle= is not specified. We need to choose some default. Would False be a better choice?

Ah, I see. I prefer shuffle=True because it's the right choice from an optimization perspective. For example, what if the Dask Dataframe are CSVs from each state? Calling partial_fit on any one CSV is not the right answer if each CSV is very different.

I think that in this function shuffle is only per-partitions, not between partitions. I think that we would leave inter-partition shuffling to the user ahead of sending to Hyperband

I think that in this function shuffle is only per-partitions, not between partitions.

That's not true; it looks like for default value of blockwise depends on whether it's a Dask Array or DataFrame:

But that's unrelated to this PR. I think shuffle=True is a good choice in case there's order. Maybe we should make _get_train_test_split public?

Maybe we should make _get_train_test_split public?

What's the motivation for that?

In case someone wants a specific train/test split. Maybe they have time series and don't want shuffle=True or blockwise=True? Or maybe they want the test set to be a specific chunk from the Dask Array?

shuffle=True, blockwise=True was the default behavior on master, and that's still what we have?

shuffle=True is definitely the behavior on master; shuffle=False isn't supported (_split.py#L493, _split.py#L477), and blockwise is False for DataFrames, and True for Arrays. I think that's the right behavior.

I need to investigate blockwise some; I'm not sure if there's a mixup in the documentation or implementation.

I think blockwise is backwards for DataFrame in the documentation & implementation. It only supports the equivalent of blockwise=True (within-block shuffling).

I think blockwise is backwards for DataFrame in the documentation & implementation. It only supports the equivalent of blockwise=True (within-block shuffling).

I'm a little confused. Should the implementation support shuffling between chunks or within chunks? I'd like to see train_test_split support shuffling between chunks. Currently, train_test_split only supports shuffling within chunks blockwise=True:

import pandas as pd
import numpy as np
import pandas as pd
import dask.dataframe as dd
from dask_ml.model_selection import train_test_split

N = 1000
df = pd.DataFrame({"x": np.arange(N), "y": np.arange(N)})
ddf = dd.from_pandas(df, npartitions=2)

kwargs = dict(random_state=0, train_size=0.5)
train, test = train_test_split(ddf, blockwise=True, **kwargs)
assert train.compute().shape == (530, 2)
train, test = train_test_split(ddf, blockwise=False, **kwargs)  # raises NotImplementedError

Should the implementation support shuffling between chunks or within chunks?

Ideally either. But that's distinct from this PR.