Model serialization formats (pickle, ONNX, TorchScript) in MLOps - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding model serialization formats

Which of the following statements correctly describes the main difference between pickle and ONNX model serialization formats?

A Pickle serializes Python objects including models, but ONNX is a platform-independent format for representing models to run on different frameworks.

B Pickle is a binary format for GPU acceleration, while ONNX only works with CPU models.

C Pickle converts models to JSON format, whereas ONNX saves models as plain text files.

D Pickle is used only for TensorFlow models, and ONNX is exclusive to PyTorch.

💡 Hint

Think about portability and framework independence.

Pickle saves Python objects as they are, which makes them Python-specific and less portable. ONNX is designed to be a universal format that can be used across different frameworks and platforms.

💻 Command Output

intermediate

TorchScript model saving output

What is the expected output when running the following PyTorch code snippet?

import torch
import torchvision.models as models
model = models.resnet18(pretrained=False)
scripted_model = torch.jit.script(model)
torch.jit.save(scripted_model, 'resnet18_scripted.pt')
print('Model saved successfully')

A Model saved successfully

B TypeError: 'ResNet' object is not callable

C FileNotFoundError: [Errno 2] No such file or directory: 'resnet18_scripted.pt'

D RuntimeError: torch.jit.script failed due to unsupported operation

💡 Hint

Consider what the print statement outputs after saving.

The code scripts the model and saves it to a file. If no errors occur, the print statement outputs the success message.

❓ Troubleshoot

advanced

Troubleshooting ONNX model loading error

You exported a PyTorch model to ONNX format but get this error when loading it in another framework: ValueError: Unsupported ONNX opset version. What is the most likely cause?

A The PyTorch model was not scripted before exporting to ONNX.

B The model file is corrupted due to incomplete download.

C The ONNX runtime is not installed on the system.

D The ONNX model was exported with a newer opset version than the target framework supports.

💡 Hint

Opset versions define supported operations in ONNX.

If the ONNX model uses a newer opset version than the runtime supports, it cannot load the model properly, causing this error.

🔀 Workflow

advanced

Choosing the right serialization format for deployment

You have a PyTorch model that you want to deploy on a mobile device with limited resources and no Python environment. Which serialization format is best suited for this deployment?

A Saving the raw PyTorch model weights as a .pth file.

B TorchScript, because it compiles the model into a standalone format runnable without Python.

C ONNX, because it requires a Python interpreter to run.

D Pickle, because it preserves all Python objects and dependencies.

💡 Hint

Consider the environment constraints and runtime requirements.

TorchScript compiles models into a format that can run independently of Python, ideal for mobile deployment. Pickle requires Python, ONNX needs compatible runtime, and raw weights need Python code to load.

✅ Best Practice

expert

Best practice for model versioning with serialization formats

When managing multiple versions of machine learning models serialized with different formats (pickle, ONNX, TorchScript), what is the best practice to ensure reproducibility and smooth deployment?

A Convert all models to ONNX format regardless of original framework to unify deployment.

B Only keep the latest model version in pickle format to reduce storage space.

C Store each model version with metadata including format, framework version, and opset version in a version control system or model registry.

D Avoid storing metadata and rely on file timestamps to track versions.

💡 Hint

Think about traceability and compatibility.

Storing detailed metadata with each model version helps track compatibility, reproduce results, and manage deployments effectively. Ignoring metadata or relying on timestamps can cause confusion and errors.

Practice

1. Which model serialization format is Python-specific and not ideal for sharing models across different platforms?

easy

A. Pickle

B. ONNX

C. TorchScript

D. JSON

Solution

1. Step 1: Understand Pickle's scope

   Pickle is a Python library that serializes Python objects but is limited to Python environments.

2. Step 2: Compare with other formats

   ONNX and TorchScript are designed for cross-platform use, unlike Pickle.

3. Final Answer:

   Pickle -> Option A

4. Quick Check:

   Python-only format = Pickle [OK]

Hint: Pickle = Python-only, others are cross-platform [OK]

Common Mistakes:

• Confusing ONNX as Python-only
• Thinking TorchScript is Python-specific
• Selecting JSON which is not a model format

2. Which of the following is the correct Python code snippet to save a PyTorch model using TorchScript?

easy

A. onnx.save(model, 'model.pt')

B. torch.save(model, 'model.pt')

C. pickle.dump(model, open('model.pt', 'wb'))

D. torch.jit.save(torch.jit.script(model), 'model.pt')

Solution

1. Step 1: Identify TorchScript saving method

   TorchScript models are saved using torch.jit.save after scripting the model with torch.jit.script.

2. Step 2: Check other options

   torch.save(model, 'model.pt') saves a PyTorch model but not as TorchScript. pickle.dump(model, open('model.pt', 'wb')) uses pickle, and onnx.save(model, 'model.pt') is invalid syntax.

3. Final Answer:

   torch.jit.save(torch.jit.script(model), 'model.pt') -> Option D

4. Quick Check:

   TorchScript save = torch.jit.save + torch.jit.script [OK]

Hint: TorchScript save needs torch.jit.script before torch.jit.save [OK]

Common Mistakes:

• Using torch.save instead of torch.jit.save
• Trying to save ONNX model with onnx.save (wrong syntax)
• Using pickle for TorchScript models

3. Given the following Python code snippet, what will be the output type of the loaded model?

import torch
import pickle

model = SomePyTorchModel()
# Save with pickle
with open('model.pkl', 'wb') as f:
    pickle.dump(model, f)

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

print(type(loaded_model))

medium

A. <class 'torch.jit.ScriptModule'>

B. <class '__main__.SomePyTorchModel'>

C. <class 'onnx.ModelProto'>

D. TypeError

Solution

1. Step 1: Understand pickle serialization

   Pickle saves and loads the exact Python object, so the loaded model keeps the original class type.

2. Step 2: Analyze output type

   Since model was saved with pickle, loaded_model is the same class as the original model.

3. Final Answer:

   <class '__main__.SomePyTorchModel'> -> Option B

4. Quick Check:

   Pickle load returns original Python object type [OK]

Hint: Pickle load returns original Python object type [OK]

Common Mistakes:

• Confusing TorchScript or ONNX types with pickle load
• Expecting a TorchScript or ONNX model type
• Assuming a TypeError occurs on loading

4. You tried to load a model saved with TorchScript using pickle.load() and got an error. What is the most likely cause?

medium

A. TorchScript models cannot be loaded with pickle.load()

B. The model file is corrupted

C. pickle.load() requires the model to be saved as ONNX

D. TorchScript models must be loaded with torch.load()

Solution

1. Step 1: Understand serialization compatibility

   TorchScript models are saved in a special format and cannot be loaded by pickle.load(), which expects Python pickle format.

2. Step 2: Identify correct loading method

   TorchScript models should be loaded with torch.jit.load(), not pickle.load().

3. Final Answer:

   TorchScript models cannot be loaded with pickle.load() -> Option A

4. Quick Check:

   pickle.load() incompatible with TorchScript [OK]

Hint: TorchScript needs torch.jit.load(), not pickle.load() [OK]

Common Mistakes:

• Assuming torch.load() works for TorchScript
• Thinking ONNX is required for pickle.load()
• Blaming file corruption without checking method

5. You want to deploy a PyTorch model to a production environment that does not have Python installed. Which serialization format should you choose and why?

hard

A. Pickle, because it is simple and fast

B. JSON, because it stores model weights efficiently

C. TorchScript, because it can run independently of Python

D. ONNX, because it is Python-only and easy to use

Solution

1. Step 1: Identify deployment constraints

   The environment lacks Python, so the model format must run without Python dependencies.

2. Step 2: Compare serialization formats

   Pickle requires Python, ONNX is cross-platform but needs an ONNX runtime, TorchScript can run independently using PyTorch's C++ runtime.

3. Step 3: Choose best fit

   TorchScript is designed for deployment without Python, making it the best choice here.

4. Final Answer:

   TorchScript, because it can run independently of Python -> Option C

5. Quick Check:

   Deploy without Python = TorchScript [OK]

Hint: No Python? Use TorchScript for standalone deployment [OK]

Common Mistakes:

• Choosing Pickle which needs Python
• Confusing ONNX as Python-only
• Selecting JSON which is not a model format