Introduction

If you see datasets.fetch_mldata in an old notebook, you are looking at legacy scikit-learn code. The function depended on the old mldata.org service, and modern scikit-learn workflows should use fetch_openml or a local saved dataset instead.

Why fetch_mldata No Longer Works

Older tutorials often loaded datasets like this:

from sklearn import datasets

mnist = datasets.fetch_mldata("MNIST original")

That code is now historical. scikit-learn deprecated fetch_mldata after mldata.org stopped operating, and newer releases removed the function entirely. In practical terms, that means the correct fix is usually migration, not debugging.

The modern replacement for many hosted datasets is fetch_openml, which retrieves datasets from OpenML.

Replacing It with fetch_openml

For MNIST, the direct replacement looks like this:

1from sklearn.datasets import fetch_openml
2
3mnist = fetch_openml(name="mnist_784", version=1, as_frame=False)
4X = mnist.data
5y = mnist.target.astype("int64")
6
7print(X.shape)
8print(y.shape)

A few details matter here:

• 'name selects the dataset.'
• 'version=1 makes the result reproducible.'
• 'as_frame=False gives NumPy arrays, which match many older examples more closely.'
• 'y is often converted to integers because OpenML labels may arrive as strings.'

That last point is easy to miss. Many downstream metrics and visualizations assume numeric labels, so casting early keeps the rest of the code simpler.

Running an End-to-End Example

A dataset fetch is only part of the migration. It is better to run a complete example so you catch shape, dtype, and training issues at the same time.

1from sklearn.datasets import fetch_openml
2from sklearn.linear_model import LogisticRegression
3from sklearn.metrics import accuracy_score
4from sklearn.model_selection import train_test_split
5
6mnist = fetch_openml(name="mnist_784", version=1, as_frame=False)
7X = mnist.data / 255.0
8y = mnist.target.astype("int64")
9
10X_train, X_test, y_train, y_test = train_test_split(
11    X,
12    y,
13    test_size=0.2,
14    random_state=42,
15    stratify=y,
16)
17
18model = LogisticRegression(max_iter=200, solver="lbfgs", multi_class="auto")
19model.fit(X_train, y_train)
20
21predictions = model.predict(X_test)
22print("accuracy:", accuracy_score(y_test, predictions))

This confirms more than just the download step. It verifies that the data format still fits a modern estimator pipeline.

Caching and Local Copies

Network-based dataset loading is convenient, but it is a weak foundation for tests, demos, or CI jobs. fetch_openml supports caching, which helps repeated runs.

from sklearn.datasets import fetch_openml

mnist = fetch_openml("mnist_784", version=1, cache=True, as_frame=False)

If you want a fully local workflow, save the arrays after the first successful download.

1import joblib
2from sklearn.datasets import fetch_openml
3
4mnist = fetch_openml("mnist_784", version=1, as_frame=False)
5joblib.dump((mnist.data, mnist.target.astype("int64")), "mnist_784.joblib")

Later you can load the file directly:

1import joblib
2
3X, y = joblib.load("mnist_784.joblib")
4print(X.shape, y.shape)

This avoids unexpected failures when a network is unavailable.

When a Built-In Dataset Is Better

Sometimes you are not trying to reproduce the exact dataset from a legacy example. You just need a quick classification dataset to test the rest of your pipeline. In that case, a built-in dataset is easier and faster.

1from sklearn.datasets import load_digits
2
3sample = load_digits()
4print(sample.data.shape)
5print(sample.target.shape)

load_digits is much smaller than MNIST, which makes it a good choice for local demos and unit tests.

Migrating Old Code Carefully

Legacy notebooks often assume very specific return types or metadata names. Modern dataset loaders may return a Bunch with slightly different attributes, and defaults have changed over time. When migrating, inspect both type(mnist.data) and type(mnist.target) instead of assuming the old shapes and dtypes still apply.

It is also worth pinning exact dataset versions when results matter. OpenML can host multiple versions of a dataset name, so versioned loading is safer than relying on a moving default.

Common Pitfalls

A common mistake is trying to install an ancient scikit-learn just to revive fetch_mldata. That may work temporarily, but it pushes the maintenance problem elsewhere and leaves you on unsupported tooling.

Another issue is forgetting to convert labels. If target arrives as strings and later code expects integers, errors can appear far away from the loading step.

Developers also sometimes fetch a large remote dataset when a tiny built-in one would have been enough to verify the surrounding code. That slows down development and makes tests more fragile.

Finally, omit the dataset version only if you truly do not care about reproducibility. For articles, notebooks, and teaching material, an explicit version is usually better.

Summary

• 'fetch_mldata is legacy API and should be replaced, not debugged.'
• Use fetch_openml for datasets that used to come from mldata.org.
• Set an explicit dataset version for reproducible results.
• Convert target labels early if downstream code expects numeric types.
• Cache or save local copies when offline or repeatable execution matters.