After your machine learning model is performing well, it might seem ready for production. You might save it with pickle.dump(model, open(‘model.pkl’, ‘wb’)), zip the file, and send it to your engineering team. But then you hear back that it doesn’t work on their machine. Saving a model for production involves more than just serializing the weights; you need to package a system that can be reproduced. In this article, I’ll show you how to properly save your ML models for production.
A Step-by-Step Guide to Save Production-Ready ML Models
Here’s how to bundle your model so it works everywhere, every time.
Step 1: Bundle Your Entire Pipeline
Your first mistake is often saving just the model. You should save the entire pipeline that touches raw data.
This includes StandardScaler, OneHotEncoder, imputation steps, and your model, all wrapped in a single object.
Here’s an example:
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
# 1. Define your preprocessing for numeric and categorical features
# ... (preprocessor code) ...
# 2. Define your model
model = LogisticRegression(max_iter=1000)
# 3. Create the *full* pipeline
full_pipeline = Pipeline([
('preprocessor', preprocessor_object), # Your scaler, encoder, etc.
('model', model)
])
# 4. Train THIS pipeline object
full_pipeline.fit(X_train, y_train)
# 5. NOW save the *entire pipeline*
import joblib
joblib.dump(full_pipeline, 'model_pipeline.joblib')Now, for prediction, you just load model_pipeline.joblib and call .predict() on the raw, unprocessed data. The pipeline handles all the scaling and encoding internally, just as it learned to do during training. This eliminates preprocessing drift between training and production.
Step 2: Freeze Your Environment
This is the most critical, most-often-missed step. You must record the exact library versions you used to create the model.
If you trained with scikit-learn==1.2.0, it is not guaranteed to work with scikit-learn==1.3.1. A tiny, subtle change in a function’s default behavior can break your predictions.
So, use a virtual environment (like venv or conda) from the start of your project. When you’re ready to save your model, run this in your terminal:
pip freeze > requirements.txt
requirements.txt is nothing but a file containg all your dependencies. Here’s an example from a project I am working on recently:
requirements.txt
llama-cpp-python>=0.2.73
sentence-transformers>=2.2.2
chromadb>=0.4.0
fitz
treamlit
tqdm
numpy
scikit-learn
nltk
pdfplumber
Step 3: Create the Model Bundle
Your production-ready model is not a single file. It’s a directory. This directory is the self-contained package you can hand off to anyone.
Here’s an example of a project directory:
- model_pipeline.joblib: This is your actual serialized pipeline from Step 1.
- requirements.txt: Your environment blueprint from Step 2.
- predict.py: A simple script showing how to use the model. This is a gift to your colleagues. It removes all guesswork.
Step 4: Version and Track Your Bundle
Now, zip this entire folder (my_model_v1.zip) and store it. When you retrain your model in a month, you’ll create my_model_v2.zip.
In a professional setting, this storage isn’t just a folder on your computer. It’s a Model Registry. Tools like MLflow, Weights & Biases, or DVC are built specifically for this. They version your model, its environment, and its performance metrics all in one place.
Final Words
I remember the first time I did this. It felt slow. It was so much extra work compared to just saving a .pkl file. But I learned a valuable lesson that a model that only runs on your laptop isn’t a product; it’s just an experiment. This process is what separates data science from data engineering.
I hope you liked this article on how to properly save your ML models for production. Feel free to ask valuable questions in the comments section below. You can follow me on Instagram for many more resources.
