Fix “X has 8 features,
but RandomForestClassifier
is expecting 9.”
The full ValueError: X has N features, but RandomForestClassifier is expecting M features as input is the most common scikit-learn production error. We diagnose 5 root causes — categorical encoding mismatch, fit_transform() misuse, target leakage, array slicing, and skipped pipelines — and give you copy-paste fixes for each. Every code block has a copy button.
ValueError: X has 8 features, but RandomForestClassifier is expecting 9 features as input
The most common scikit-learn
production error.
If you’re training a machine learning model in Python and suddenly hit ValueError: X has 8 features, but RandomForestClassifier is expecting 9 features as input (or any variation like 8 vs 9, 13 vs 30, or 28 vs 784), you are not alone. This is one of the most common exceptions encountered by beginners and seasoned data scientists alike when transitioning from model training to inference.
In scikit-learn, the RandomForestClassifier checks the matrix shape during predict() or predict_proba() against the number of features recorded in its n_features_in_ attribute during fit(). If the incoming matrix does not match the exact column count of the training matrix, scikit-learn immediately halts execution to prevent silent, corrupt predictions. The 5 root causes are: (1) categorical encoding mismatch when pd.get_dummies() is run separately on train and test; (2) calling fit_transform() instead of transform() on vectorizers; (3) retaining the target or ID column in training data; (4) inconsistent array reshaping or dimension slicing; and (5) skipping feature selection / reduction steps during inference.
Whether you are developing locally or following our step-by-step guide to debugging Python code in Google Colab, understanding why your feature dimensions diverged is key to building production-ready models. The fix is almost always one of five patterns — and once you recognize which one you’re hitting, the patch takes about 15 minutes.
Check expected vs.
actual features.
Before diving into the 5 causes, run these three lines of diagnostic Python code right before your predict() call to inspect your model and dataset state. The output will tell you exactly which cause you’re hitting.
# 1. Check how many features your model expects print("Model expects:", clf.n_features_in_, "features") # 2. Check how many features your test set actually has print("Test dataset has:", X_test.shape, "features") # 3. If using pandas DataFrames, check the feature names stored in the model if hasattr(clf, "feature_names_in_"): print("Expected Feature Names:", clf.feature_names_in_)
Compare the two numbers. If Model expects > Test dataset has, you’re missing columns — usually Cause 1 (categorical encoding) or Cause 2 (vectorizer refit). If Model expects < Test dataset has, you have extra columns — usually Cause 3 (target/ID leakage in training). The feature_names_in_ list tells you exactly which columns the model wants, so you can compare against X_test.columns and see what’s missing or extra.
5 root causes,
5 copy-paste fixes.
Each cause below has a broken code example (so you can recognize the pattern) and a working fix (so you can copy it into your project). All code blocks have copy buttons.
Cause 1: Categorical Encoding Mismatch with pd.get_dummies()
The single most common culprit behind ValueError: X has 8 features, but RandomForestClassifier is expecting 9 features as input is running pd.get_dummies() separately on X_train and X_test.
If a categorical column in X_train contains 3 unique values (e.g., "NYC", "LA", "SF"), one-hot encoding expands it into 3 binary columns. However, if your test sample or single-row prediction only contains "NYC" and "LA", pd.get_dummies() will only create 2 columns for the test set — leaving your test matrix with 8 features instead of the expected 9.
❌ Code That Triggers the Error:
import pandas as pd from sklearn.ensemble import RandomForestClassifier # Training Data (Creates 9 feature columns) df_train = pd.DataFrame({ 'age': [25, 30, 35], 'salary': [50000, 60000, 70000], 'city': ['NYC', 'LA', 'SF'], # 3 categories 'device': ['iOS', 'Android', 'Web'], # 3 categories 'tier': ['Free', 'Paid', 'VIP'] # 3 categories }) X_train = pd.get_dummies(df_train) # Total: 9 features (2 numeric + 3 + 3 + 1 redundant) y_train = [0, 1, 0] clf = RandomForestClassifier(random_state=42) clf.fit(X_train, y_train) # Test Data (Missing 'SF' category in city, 'Web' in device, 'VIP' in tier) df_test = pd.DataFrame({ 'age': [28], 'salary': [55000], 'city': ['NYC'], # Only 1 category present! 'device': ['iOS'], 'tier': ['Paid'] }) X_test = pd.get_dummies(df_test) # Only 5 features created! # Throws: ValueError: X has 5 features, but RandomForestClassifier is expecting 11 features as input clf.predict(X_test)
✅ Fix 1A: Reindex Columns Using X_train.columns
Align the test DataFrame columns to match the exact schema of X_train using the pandas DataFrame align method or .reindex(), filling missing category columns with 0:
# Align test set columns to match training set columns exactly X_test_aligned = pd.get_dummies(df_test).reindex(columns=X_train.columns, fill_value=0) # Now X_test_aligned has the same 9 features! predictions = clf.predict(X_test_aligned) print("Predictions:", predictions)
✅ Fix 1B: Use OneHotEncoder(handle_unknown='ignore')
A robust MLOps approach is using scikit-learn‘s native encoder, which learns categories during fit() and preserves column dimensions during inference:
from sklearn.preprocessing import OneHotEncoder encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False) X_train_encoded = encoder.fit_transform(df_train[['city', 'device', 'tier']]) X_test_encoded = encoder.transform(df_test[['city', 'device', 'tier']]) # Always outputs matching shape!
OneHotEncoder wins in production: Unlike pd.get_dummies(), it’s stateful — it remembers which categories it saw during fit() and always emits the same columns during transform(), even if the test data has fewer or unseen categories. The handle_unknown='ignore' flag tells it to silently zero out unseen categories instead of throwing.Cause 2: Calling fit_transform() Instead of transform() on Vectorizers
When dealing with text classification or Natural Language Processing (NLP), calling fit_transform() on inference data recreates the vocabulary dictionary from scratch.
If your training vocabulary contained 9 unique words, but your new input text sample only contains 8 unique words, calling fit_transform() builds an 8-column matrix — triggering the exact dimension error on your RandomForestClassifier estimator.
❌ Code That Triggers the Error:
from sklearn.feature_extraction.text import CountVectorizer from sklearn.ensemble import RandomForestClassifier train_documents = ["alpha beta gamma delta epsilon zeta eta theta iota"] vectorizer = CountVectorizer() X_train = vectorizer.fit_transform(train_documents) # Vocabulary size: 9 y_train = [1] clf = RandomForestClassifier(random_state=42) clf.fit(X_train, y_train) # Inference on a shorter sample test_document = ["alpha beta gamma delta epsilon zeta eta theta"] # ERROR: Re-fitting vectorizer creates an 8-feature vocabulary! X_test_wrong = vectorizer.fit_transform(test_document) # Throws: ValueError: X has 8 features, but RandomForestClassifier is expecting 9 features as input # clf.predict(X_test_wrong)
✅ Fix: Use vectorizer.transform() for Test Data
Always use .transform() on validation, test, or production prediction inputs so that the preprocessor applies the existing learned feature map:
# Correct: Reuse the fitted vocabulary map from X_train X_test_correct = vectorizer.transform(test_document) # Correctly outputs 9 features (with 0s for missing words) predictions = clf.predict(X_test_correct) print("Prediction:", predictions)
fit_transform() is called exactly once on training data. Every subsequent call — validation, test, single-row REST API prediction, batch scoring — uses transform() only. This applies to CountVectorizer, TfidfVectorizer, OneHotEncoder, StandardScaler, MinMaxScaler, PCA, SelectKBest, and every other stateful scikit-learn transformer.Cause 3: Retaining Target (y) or ID Columns in Training Data
Another frequent beginner trap is passing the complete raw DataFrame (which includes the target label column 'target' or a unique 'user_id') to clf.fit(X_train, y_train).
In this scenario, if your original dataset had 8 predictor features plus 1 target column, the RandomForestClassifier fits on all 9 columns. Later, when you correctly drop the target column from your test set (leaving 8 features), the classifier expects 9 features and fails.
❌ Code That Triggers the Error:
import pandas as pd from sklearn.ensemble import RandomForestClassifier df = pd.DataFrame({ 'f1': [1,2,3], 'f2': [4,5,6], 'f3': [7,8,9], 'f4': [1,2,3], 'f5': [4,5,6], 'f6': [7,8,9], 'f7': [1,2,3], 'f8': [4,5,6], 'target': [0,1,0] # 9th column! }) # BUG: Passing the whole DataFrame as X_train without dropping 'target' X_train_faulty = df # 9 columns total y_train = df['target'] clf = RandomForestClassifier(random_state=42) clf.fit(X_train_faulty, y_train) # Model fits expecting 9 features # Correctly prepared inference sample (8 features) X_test = df.drop(columns=['target']) # 8 columns # Throws: ValueError: X has 8 features, but RandomForestClassifier is expecting 9 features as input # clf.predict(X_test)
✅ Fix: Explicitly Separate X and y Before Fitting
# Properly separate predictors and target labels X = df.drop(columns=['target']) # 8 predictor features y = df['target'] clf = RandomForestClassifier(random_state=42) clf.fit(X, y) # Model fits on 8 features # Prediction now works seamlessly predictions = clf.predict(X_test) print("Predictions:", predictions)
X_train.columns before fitting and confirm 'target', 'user_id', 'id', and similar identifiers are absent.Cause 4: Inconsistent Array Reshaping & Dimension Slicing
When working with NumPy arrays, matrix reshaping, or image processing patches (such as 3×3 pixel grids = 9 features), slicing arrays improperly can drop a feature axis.
If your training matrix was reshaped to (N, 9), but your prediction sample was sliced as np.array(sample[:8]) or reshaped without accounting for all channels, scikit-learn will report X has 8 features, but RandomForestClassifier is expecting 9 features as input.
If you are working with computer vision arrays in Colab, review our tutorial on how to visualize images and matrices in Google Colab to verify your array shapes before feeding them into models.
❌ Code That Triggers the Error:
import numpy as np from sklearn.ensemble import RandomForestClassifier # Training data: 100 samples with 9 numerical features X_train = np.random.rand(100, 9) y_train = np.random.randint(0, 2, 100) clf = RandomForestClassifier(random_state=42) clf.fit(X_train, y_train) # Inference sample sliced incorrectly (only 8 elements) sample_input = np.random.rand(8) # Throws: ValueError: X has 8 features, but RandomForestClassifier is expecting 9 features as input # clf.predict(sample_input.reshape(1, -1))
✅ Fix: Verify and Enforce Matrix Shape (1, 9)
# Correct: Ensure the sample contains exactly 9 feature elements correct_sample = np.random.rand(9).reshape(1, -1) # Shape: (1, 9) # Always assert the shape before predicting assert correct_sample.shape == (1, clf.n_features_in_), \ f"Expected (1, {clf.n_features_in_}), got {correct_sample.shape}" prediction = clf.predict(correct_sample) print("Sample Prediction:", prediction)
Cause 5: Skipping Feature Selection / Reduction Steps During Inference
If your training pipeline applies feature selection (such as SelectKBest(k=9)) or dimensionality reduction (such as PCA(n_components=9)) to a raw 12-feature dataset, the fitted RandomForestClassifier will operate on 9 transformed features.
If you pass a raw 8-feature or 12-feature dataset directly to clf.predict() in production without passing it through selector.transform(), feature count mismatches are inevitable.
❌ Code That Triggers the Error:
import pandas as pd from sklearn.ensemble import RandomForestClassifier from sklearn.feature_selection import SelectKBest, f_classif # Raw dataset with 12 features X_raw = pd.DataFrame({f"feat_{i}": range(10) for i in range(12)}) y_train = [0, 1] * 5 # Select top 9 features selector = SelectKBest(score_func=f_classif, k=9) X_selected = selector.fit_transform(X_raw, y_train) # 9 features clf = RandomForestClassifier(random_state=42) clf.fit(X_selected, y_train) # Inference: Passing a raw input DataFrame directly without transformation X_test_raw = pd.DataFrame({f"feat_{i}": [1] for i in range(12)}) # ERROR: Passing 12 raw features to a model expecting 9! # clf.predict(X_test_raw)
✅ Fix: Encapsulate Your Pipeline with Pipeline
The gold standard for preventing feature count mismatches in production is chaining transformers and estimators using the scikit-learn Pipeline or ColumnTransformer:
from sklearn.pipeline import Pipeline # Build an end-to-end reproducible pipeline pipeline = Pipeline([ ('feature_selection', SelectKBest(score_func=f_classif, k=9)), ('classifier', RandomForestClassifier(random_state=42)) ]) # Fit pipeline on raw data pipeline.fit(X_raw, y_train) # Predict directly on raw test data - Pipeline handles transformation automatically! predictions = pipeline.predict(X_test_raw) print("Pipeline Predictions:", predictions) # Save as a single artifact - no separate encoder/selector needed import joblib joblib.dump(pipeline, 'model_pipeline.pkl')
sklearn.pipeline.Pipeline. Then save the pipeline, not the model, with joblib.dump(pipeline, 'model.pkl'). At inference time, load the pipeline and call predict() on raw input — the pipeline handles every transformation consistently. This eliminates Causes 1, 2, and 5 in a single architectural decision.If you’re still seeing
the error.
If you’re still seeing feature mismatch errors when running your script or deploying Streamlit web applications from Google Colab, follow this 4-step checklist:
From broken
predict() to working
production model.
Run these checks in order. The first one that fails is your culprit.
Check dependency installation
Ensure your environment has consistent library versions. Refer to our guide on how to install required Python packages in Google Colab if you suspect library version drift between scikit-learn, pandas, and numpy.
Inspect feature column names
Print set(X_train.columns) - set(X_test.columns) to identify exactly which features are missing or extra in your test data. Also print clf.feature_names_in_ to see what the model remembers.
Never re-fit preprocessors
Verify that you only call fit() or fit_transform() once on your training set. Use transform() exclusively for validation and test sets. Grep your codebase for fit_transform and audit each call.
Save pipelines as single artifacts
Save your fitted Pipeline object using joblib.dump(pipeline, 'model_pipeline.pkl') rather than saving the classifier and encoders separately. This eliminates the entire class of “I forgot to apply the encoder at inference” bugs.
Common questions
about the error.
Why does RandomForestClassifier require the exact same number of features? +
Each decision tree inside a Random Forest splits nodes based on specific feature column indices learned during training. If column counts shift during inference, the mathematical index mapping breaks, leading to invalid predictions. scikit-learn enforces this check via the n_features_in_ attribute to prevent silent data corruption.
How do I fix “X has 8 features, but expecting 9” when making single-row REST API predictions? +
Wrap your single input dictionary into a pandas DataFrame (e.g., df_sample = pd.DataFrame([input_dict])), and apply df_sample.reindex(columns=trained_feature_names, fill_value=0) before passing it to predict(). This ensures all expected columns are present, with zeros for any missing categorical levels.
Can I disable the feature count check in scikit-learn? +
No. The feature count validation is a core safety mechanism in scikit-learn designed to prevent silent data corruption and invalid model inference. The check is hardcoded into the predict() and predict_proba() methods of all supervised estimators. The correct fix is to align your input features, not to bypass the check.
What is the difference between fit_transform() and transform() in scikit-learn? +
fit_transform() learns the parameters (vocabulary, categories, mean, variance) from the input data AND applies the transformation in one step. transform() only applies the previously learned parameters. You must call fit_transform() exactly once on training data, then transform() on all validation, test, and production data. Calling fit_transform() on test data resets the learned parameters and causes feature count mismatches.
Should I use pd.get_dummies() or OneHotEncoder for production models? +
Always prefer OneHotEncoder for production. pd.get_dummies() is stateless — it creates columns based on whatever categories happen to be in the input DataFrame, so train and test sets can produce different column counts. OneHotEncoder is stateful — it learns the category list during fit() and applies the same columns during transform(), with handle_unknown='ignore' to gracefully handle unseen categories.
What is n_features_in_ and when was it added to scikit-learn? +
n_features_in_ is an attribute stored on every fitted scikit-learn estimator that records the number of features seen during fit(). It was introduced in scikit-learn 1.0 (released September 2021) as part of a broader effort to enforce input validation. The companion attribute feature_names_in_ stores the actual column names when pandas DataFrames are used.
Will switching to XGBoost or LightGBM avoid this error? +
No — XGBoost, LightGBM, CatBoost, and most other gradient-boosting libraries have equivalent feature-count checks. XGBoost throws feature_names_mismatch, LightGBM throws Number of features differs. The root causes are the same regardless of library. Fix the data pipeline, not the estimator choice.
Fix the error
in 15 minutes.
Run the 3-line diagnostic, identify your cause, copy the matching fix. Or click “Copy All Fix Snippets” at the top of this page to get every fix in one click.
Share this Fix
If this guide saved your production deployment, share it with your team and fellow developers.