Model serialization formats (pickle, ONNX, TorchScript) in MLOps - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to save a model using pickle.

MLOps

import pickle
with open('model.pkl', '[1]') as f:
    pickle.dump(model, f)

Drag options to blanks, or click blank then click option'

Ar

Brb

Cwb

Dw

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'r' or 'rb' mode which is for reading files.

Use 'wb' to write a binary file when saving a model with pickle.

2fill in blank

medium

Complete the code to export a PyTorch model to ONNX format.

MLOps

import torch
model.eval()
dummy_input = torch.randn(1, 3, 224, 224)
torch.onnx.export(model, dummy_input, '[1]')

Drag options to blanks, or click blank then click option'

Amodel.onnx

Bmodel.script

Cmodel.pkl

Dmodel.pt

Attempts:

3 left

💡 Hint

Common Mistakes

Saving ONNX model with '.pt' or '.pkl' extensions.

ONNX models are saved with the '.onnx' extension.

3fill in blank

hard

Fix the error in saving a TorchScript model.

MLOps

import torch
scripted_model = torch.jit.script(model)
scripted_model.[1]('model.pt')

Drag options to blanks, or click blank then click option'

Aexport

Bsave

Cdump

Dwrite

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'export' or 'dump' which are not valid for TorchScript.

TorchScript models use the 'save' method to write to disk.

4fill in blank

hard

Fill both blanks to load a pickled model correctly.

MLOps

import pickle
with open('model.pkl', '[1]') as f:
    model = pickle.[2](f)

Drag options to blanks, or click blank then click option'

Arb

Bwb

Cload

Ddump

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'wb' mode or pickle.dump() when loading.

To load a pickled model, open the file in 'rb' mode and use pickle.load().

5fill in blank

hard

Fill all three blanks to export a TorchScript model and save it.

MLOps

import torch
scripted = torch.jit.[1](model)
scripted.[2]('model_scripted.[3]')

Drag options to blanks, or click blank then click option'

Atrace

Bsave

Cpt

Dscript

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'trace' instead of 'script' or wrong file extensions.

Use torch.jit.script() to create a TorchScript model, then save() it with '.pt' extension.

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