Model serialization formats (pickle, ONNX, TorchScript) in MLOps - Step-by-Step Execution

Process Flow - Model serialization formats (pickle, ONNX, TorchScript)

Train Model

↓

Choose Serialization Format

↓

Pickle

↓

Save Model to Disk

↓

Load Model from Disk

↓

Use Model for Inference

This flow shows training a model, choosing a serialization format, saving it, loading it back, and using it for predictions.

Execution Sample

MLOps

import pickle
model = train_model()
with open('model.pkl', 'wb') as f:
    pickle.dump(model, f)

# Later
with open('model.pkl', 'rb') as f:
    loaded_model = pickle.load(f)

This code trains a model, saves it using pickle, then loads it back for use.

Process Table

Step	Action	Format Used	File Created/Read	Result
1	Train model	N/A	N/A	Model object created in memory
2	Serialize model	pickle	model.pkl (write)	Model saved as binary file
3	Deserialize model	pickle	model.pkl (read)	Model object restored in memory
4	Use model	N/A	N/A	Model predicts on new data

💡 Model saved and loaded successfully using pickle format

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
model	None	Trained model object	Trained model object	None	None
file handle	None	None	Open for write	Open for read	None
loaded_model	None	None	None	Restored model object	Restored model object

Key Moments - 3 Insights

Why do we need to open the file in 'wb' mode when saving the model?

Because 'wb' means write binary mode, which is required to save the model data correctly as a binary file (see Step 2 in execution_table).

What happens if we try to load the model without opening the file in 'rb' mode?

Loading requires reading binary data, so opening without 'rb' mode will cause an error or incorrect data (see Step 3 in execution_table).

Why can't we use pickle files directly in other frameworks like TorchScript or ONNX?

Pickle is Python-specific and may not be compatible with other frameworks; ONNX and TorchScript are designed for interoperability and optimized execution.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the model restored back into memory?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Check the 'Result' column for when the model object is restored in memory.

According to variable_tracker, what is the state of 'loaded_model' after Step 2?

A Restored model object

B None

C Trained model object

D File handle open

💡 Hint

Look at the 'loaded_model' row and the column 'After Step 2'.

If we change the serialization format from pickle to ONNX, which step in execution_table would change?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Serialization format affects saving the model to disk.

Concept Snapshot

Model serialization saves trained models to files for later use.
Common formats:
- pickle: Python-specific, saves objects as binary.
- ONNX: Open format for interoperability across frameworks.
- TorchScript: PyTorch's optimized format for deployment.
Save with write-binary mode, load with read-binary mode.
Choose format based on use case and compatibility.

Full Transcript

This visual execution shows how a machine learning model is trained, saved to disk using a serialization format like pickle, then loaded back for inference. The flow starts with training the model in memory, then choosing a format such as pickle, ONNX, or TorchScript. The model is saved to a file in binary mode and later loaded back by reading the file in binary mode. Variables like 'model' and 'loaded_model' change state as the model is saved and restored. Key moments clarify why file modes matter and compatibility differences between formats. The quiz tests understanding of when the model is restored, variable states, and how changing formats affects steps. The snapshot summarizes key points about serialization formats and usage.