Model optimization for serving (quantization, pruning) in MLOps - Mini Project: Build & Apply

Model Optimization for Serving with Quantization and Pruning

📖 Scenario: You work as a machine learning engineer preparing a model for deployment. To make the model faster and smaller for serving, you will apply two common optimization techniques: quantization and pruning.Quantization reduces the precision of the model weights to save space and speed up inference. Pruning removes less important weights to make the model lighter.

🎯 Goal: Build a simple Python script that simulates model weights as a dictionary, applies pruning by removing small weights, and applies quantization by rounding weights to fewer decimal places. Finally, display the optimized model weights.

📋 What You'll Learn

Create a dictionary called model_weights with specific float values representing weights.

Create a variable called prune_threshold to decide which weights to remove.

Use a dictionary comprehension to prune weights below the threshold and quantize remaining weights by rounding.

Print the final optimized model_weights dictionary.

💡 Why This Matters

🌍 Real World

Optimizing machine learning models before deployment helps reduce memory use and speeds up predictions, which is critical for real-time applications like voice assistants or recommendation systems.

💼 Career

Understanding model optimization techniques like pruning and quantization is essential for MLOps engineers and data scientists working to deploy efficient, scalable AI services.

1

Create initial model weights dictionary

Create a dictionary called model_weights with these exact entries: 'layer1': 0.2567, 'layer2': 0.0345, 'layer3': 0.7891, 'layer4': 0.0123, 'layer5': 0.4567.

MLOps

# Create the model_weights dictionary with given weights
# Your code here

Hint

Use curly braces to create a dictionary with keys as layer names and values as floats.

2

Set pruning threshold

Create a variable called prune_threshold and set it to 0.05. This will be the cutoff below which weights are removed.

MLOps

model_weights = {'layer1': 0.2567, 'layer2': 0.0345, 'layer3': 0.7891, 'layer4': 0.0123, 'layer5': 0.4567}
# Create prune_threshold variable and set to 0.05
# Your code here

Hint

Just assign the value 0.05 to the variable prune_threshold.

3

Apply pruning and quantization

Use a dictionary comprehension to create a new model_weights dictionary that only keeps weights greater than prune_threshold. Round each kept weight to 2 decimal places to simulate quantization.

MLOps

model_weights = {'layer1': 0.2567, 'layer2': 0.0345, 'layer3': 0.7891, 'layer4': 0.0123, 'layer5': 0.4567}
prune_threshold = 0.05
# Use dictionary comprehension to prune and quantize weights
# Your code here

Hint

Use {layer: round(weight, 2) for layer, weight in model_weights.items() if weight > prune_threshold} to filter and round weights.

4

Display optimized model weights

Write a print statement to display the final model_weights dictionary.

MLOps

model_weights = {'layer1': 0.2567, 'layer2': 0.0345, 'layer3': 0.7891, 'layer4': 0.0123, 'layer5': 0.4567}
prune_threshold = 0.05
model_weights = {layer: round(weight, 2) for layer, weight in model_weights.items() if weight > prune_threshold}
# Print the optimized model_weights dictionary
# Your code here

Hint

Use print(model_weights) to show the final dictionary.

Practice

1. What is the main goal of quantization in model optimization for serving?

easy

A. Increase the size of the model for better performance

B. Reduce the precision of numbers to make the model smaller and faster

C. Add more neurons to improve accuracy

D. Remove entire layers from the model to simplify it

Solution

1. Step 1: Understand quantization purpose

   Quantization reduces the number precision (like from 32-bit to 8-bit) to save memory and speed up computation.

2. Step 2: Compare options

   Removing layers is pruning, adding neurons increases size, increasing size is opposite of optimization.

3. Final Answer:

   Reduce the precision of numbers to make the model smaller and faster -> Option B

4. Quick Check:

   Quantization = Reduce precision [OK]

Hint: Quantization means lowering number precision to save space [OK]

Common Mistakes:

• Confusing pruning with quantization
• Thinking quantization adds complexity
• Believing quantization increases model size

2. Which of the following is the correct syntax to apply pruning using TensorFlow Model Optimization API in Python?

easy

A. pruned_model = tfmot.sparsity.keras.prune_low_magnitude(model, pruning_schedule=pruning_schedule)

B. pruned_model = tf.prune_low_magnitude(model, schedule=pruning_schedule)

C. pruned_model = tfmot.prune_low_magnitude(model, pruning_schedule=pruning_schedule)

D. pruned_model = tfmot.sparsity.prune_low_magnitude(model, pruning_schedule)

Solution

1. Step 1: Recall TensorFlow pruning API structure

   The pruning function is under tfmot.sparsity.keras and requires the pruning_schedule argument.

2. Step 2: Check syntax correctness

   pruned_model = tfmot.sparsity.keras.prune_low_magnitude(model, pruning_schedule=pruning_schedule) matches the correct full path and argument names. Others miss parts or have wrong argument names.

3. Final Answer:

   pruned_model = tfmot.sparsity.keras.prune_low_magnitude(model, pruning_schedule=pruning_schedule) -> Option A

4. Quick Check:

   Correct pruning syntax = pruned_model = tfmot.sparsity.keras.prune_low_magnitude(model, pruning_schedule=pruning_schedule) [OK]

Hint: TensorFlow pruning is under tfmot.sparsity.keras with pruning_schedule [OK]

Common Mistakes:

• Omitting 'keras' in the API path
• Using wrong argument names
• Calling pruning directly from tf module

3. Given the following PyTorch code snippet for quantization, what will be the output type of the model's weights after applying dynamic quantization?

import torch
import torch.nn as nn

model = nn.Linear(10, 5)
quantized_model = torch.quantization.quantize_dynamic(model, {nn.Linear}, dtype=torch.qint8)
print(type(quantized_model.weight()))

medium

A. TypeError: 'weight' is not callable

B.

C. AttributeError: 'Linear' object has no attribute 'weight'

D.

Solution

1. Step 1: Analyze dynamic quantization effect

   torch.quantization.quantize_dynamic converts nn.Linear to torch.nn.quantized.dynamic.Linear, where weight is a method returning dequantized weights as torch.Tensor.

2. Step 2: Trace the print statement

   quantized_model.weight() succeeds, returning a torch.Tensor (fp32 dequantized), so print(type(...)) outputs <class 'torch.Tensor'>.

3. Final Answer:

   <class 'torch.Tensor'> -> Option D

4. Quick Check:

   Dynamic quant: weight() returns Tensor [OK]

Hint: Dynamic quantization makes weight() callable returning Tensor [OK]

Common Mistakes:

• Thinking weight remains non-callable attribute like original Linear
• Confusing quantized_model type with weight type
• Expecting error on quantized model weight access

4. You tried pruning a TensorFlow model but got an error: AttributeError: module 'tensorflow_model_optimization' has no attribute 'sparsity'. What is the most likely cause?

medium

A. The tensorflow_model_optimization package is not installed

B. You used the wrong pruning schedule argument

C. You forgot to import tensorflow_model_optimization as tfmot

D. Pruning is not supported in TensorFlow

Solution

1. Step 1: Understand the error message

   The error says the module has no attribute 'sparsity', which usually means the package is missing or outdated.

2. Step 2: Check common causes

   If the package is not installed, Python cannot find the 'sparsity' submodule. Importing incorrectly or wrong argument causes different errors.

3. Final Answer:

   The tensorflow_model_optimization package is not installed -> Option A

4. Quick Check:

   Missing package = AttributeError [OK]

Hint: Missing package causes AttributeError on submodules [OK]

Common Mistakes:

• Assuming import alias causes error
• Blaming pruning schedule argument
• Thinking pruning unsupported in TensorFlow

5. You want to optimize a large deep learning model for mobile deployment by combining pruning and quantization. Which sequence of steps is best to minimize model size and maintain accuracy?

hard

A. Apply quantization first, then prune the model to remove weights

B. Train the model with quantization-aware training, then prune after deployment

C. First prune the model to remove unimportant weights, then apply quantization to reduce number precision

D. Only prune the model; quantization is not compatible with pruning

Solution

1. Step 1: Understand pruning and quantization order

   Pruning removes unimportant weights first, reducing model size and complexity.

2. Step 2: Apply quantization after pruning

   Quantization then reduces number precision on the smaller pruned model, further shrinking size and speeding inference.

3. Final Answer:

   First prune the model to remove unimportant weights, then apply quantization to reduce number precision -> Option C

4. Quick Check:

   Prune first, then quantize = First prune the model to remove unimportant weights, then apply quantization to reduce number precision [OK]

Hint: Prune first to shrink, then quantize to compress numbers [OK]

Common Mistakes:

• Quantizing before pruning reduces pruning effectiveness
• Thinking pruning and quantization cannot be combined
• Pruning after deployment is too late