Introduction

The error AttributeError: 'OneHotEncoder' object has no attribute '_infrequent_enabled' occurs when you load a OneHotEncoder that was trained (fitted) with one version of scikit-learn but try to use it with a different version. The _infrequent_enabled attribute was added in scikit-learn 1.0, so loading a model saved with an older version into a newer scikit-learn (or vice versa) triggers this error. The fix is to ensure version consistency between training and inference environments, or re-fit the encoder with the current version.

The Error

1import pickle
2from sklearn.preprocessing import OneHotEncoder
3
4# Load a model saved with scikit-learn 0.24
5with open("model_pipeline.pkl", "rb") as f:
6    pipeline = pickle.load(f)
7
8# Try to transform new data
9pipeline.transform(new_data)
10# AttributeError: 'OneHotEncoder' object has no attribute '_infrequent_enabled'

This happens because scikit-learn 1.0+ expects the _infrequent_enabled internal attribute on fitted OneHotEncoder objects, but models saved with earlier versions do not have it.

Root Cause: Version Mismatch

The _infrequent_enabled attribute supports the min_frequency and max_categories parameters introduced in scikit-learn 1.0. When you fit a OneHotEncoder in 1.0+, it stores _infrequent_enabled internally. Models fitted with 0.24 or earlier lack this attribute.

1import sklearn
2print(sklearn.__version__)
3# Check which version you have
4
5# In scikit-learn 1.0+, OneHotEncoder has new parameters:
6enc = OneHotEncoder(min_frequency=0.05, max_categories=10)
7# These require _infrequent_enabled to track state

Fix 1: Match scikit-learn Versions

Ensure the same scikit-learn version is used for training and inference:

1# Check the version used during training
2# If the model was saved with scikit-learn 0.24:
3pip install scikit-learn==0.24.2
4
5# Or if you want to use the latest version, retrain the model:
6pip install scikit-learn --upgrade

1# Save the scikit-learn version alongside the model
2import sklearn
3import pickle
4
5model_data = {
6    "model": pipeline,
7    "sklearn_version": sklearn.__version__
8}
9with open("model_with_version.pkl", "wb") as f:
10    pickle.dump(model_data, f)

Fix 2: Re-fit the Encoder

Re-train and re-save the model with the current scikit-learn version:

1from sklearn.preprocessing import OneHotEncoder
2import pandas as pd
3
4# Re-fit with current version
5encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
6encoder.fit(training_data[categorical_columns])
7
8# Now save — this model will have _infrequent_enabled
9import pickle
10with open("encoder_v2.pkl", "wb") as f:
11    pickle.dump(encoder, f)

Fix 3: Manually Set the Missing Attribute

As a temporary workaround, set the attribute before using the encoder:

1import pickle
2
3with open("old_model.pkl", "rb") as f:
4    encoder = pickle.load(f)
5
6# Manually add the missing attribute
7if not hasattr(encoder, '_infrequent_enabled'):
8    encoder._infrequent_enabled = False
9
10# Now transform works
11result = encoder.transform(new_data)

This is fragile and not recommended for production — it only works if the old encoder does not use infrequent categories.

Fix 4: Use joblib Instead of pickle

joblib is the recommended serialization format for scikit-learn models and handles version differences more gracefully:

1import joblib
2from sklearn.preprocessing import OneHotEncoder
3
4# Save
5encoder = OneHotEncoder(sparse_output=False)
6encoder.fit(data)
7joblib.dump(encoder, "encoder.joblib")
8
9# Load
10encoder = joblib.load("encoder.joblib")

While joblib does not prevent version mismatch errors entirely, scikit-learn issues a UserWarning when loading models from different versions, making the problem easier to diagnose.

Fix 5: Use ONNX or PMML for Portable Models

For production environments where version mismatches are common:

1# Export to ONNX (version-independent format)
2from skl2onnx import convert_sklearn
3from skl2onnx.common.data_types import StringTensorType
4
5onnx_model = convert_sklearn(
6    pipeline,
7    initial_types=[('input', StringTensorType([None, 4]))]
8)
9
10with open("model.onnx", "wb") as f:
11    f.write(onnx_model.SerializeToString())
12
13# Load with onnxruntime (no scikit-learn dependency)
14import onnxruntime as rt
15session = rt.InferenceSession("model.onnx")

Pipeline Example

The error often occurs in pipelines where OneHotEncoder is a step:

1from sklearn.pipeline import Pipeline
2from sklearn.compose import ColumnTransformer
3from sklearn.ensemble import RandomForestClassifier
4
5preprocessor = ColumnTransformer(
6    transformers=[
7        ('cat', OneHotEncoder(handle_unknown='ignore'), categorical_cols),
8    ],
9    remainder='passthrough'
10)
11
12pipeline = Pipeline([
13    ('preprocessor', preprocessor),
14    ('classifier', RandomForestClassifier())
15])
16
17pipeline.fit(X_train, y_train)
18
19# Save with version info
20import joblib, sklearn
21joblib.dump({
22    'pipeline': pipeline,
23    'sklearn_version': sklearn.__version__,
24    'feature_names': list(X_train.columns)
25}, "pipeline_bundle.joblib")

Common Pitfalls

• Different versions in training vs serving: Docker images, cloud functions, or CI/CD pipelines may install a different scikit-learn version. Pin exact versions in requirements.txt: scikit-learn==1.3.2.
• Using pickle for long-term storage: Pickle files are tied to the exact library version and Python version. Use ONNX or re-train for long-lived models.
• sparse_output vs sparse parameter: In scikit-learn 1.2+, sparse was renamed to sparse_output. Using the old name with a new version triggers FutureWarning or errors.
• Forgetting handle_unknown='ignore': Without this, OneHotEncoder.transform() raises an error if new data contains categories not seen during fitting. Always set it in production pipelines.
• Not checking sklearn.__version__ on load: Always log or check the scikit-learn version when loading saved models to catch mismatches early.

Summary

• The error is caused by a scikit-learn version mismatch between training and inference
• _infrequent_enabled was added in scikit-learn 1.0 for the min_frequency/max_categories feature
• Fix by matching versions, re-fitting the encoder, or manually setting the attribute
• Pin scikit-learn versions in requirements.txt and save version metadata alongside models
• For portable models, consider ONNX or other version-independent formats