TorchScript export in PyTorch - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this TorchScript export code?

Consider this PyTorch model and its TorchScript export. What will be printed after running the code?

PyTorch

import torch
import torch.nn as nn

class SimpleModel(nn.Module):
    def forward(self, x):
        return x * 2

model = SimpleModel()
scripted_model = torch.jit.script(model)
print(scripted_model(torch.tensor(3)))

A tensor(9)

B tensor(3)

C tensor(6)

D TypeError

💡 Hint

Think about what the model does to the input tensor.

The model multiplies the input by 2. Input is 3, so output is 6 wrapped in a tensor.

❓ Model Choice

intermediate

Which model can be successfully exported with torch.jit.script?

Given these PyTorch models, which one will torch.jit.script successfully export without errors?

PyTorch

import torch
import torch.nn as nn

class ModelA(nn.Module):
    def forward(self, x):
        if x.sum() > 0:
            return x * 2
        else:
            return x - 2

class ModelB(nn.Module):
    def forward(self, x):
        return x.numpy() + 1

class ModelC(nn.Module):
    def forward(self, x):
        return x + 1

class ModelD(nn.Module):
    def forward(self, x):
        return x.tolist()

A ModelA

B ModelB

C ModelC

D ModelD

💡 Hint

TorchScript does not support converting tensors to numpy or list inside scripted models.

ModelA uses only PyTorch operations and control flow supported by TorchScript. ModelB and ModelD use unsupported tensor conversions. ModelC is simple but does not have control flow, so it also works but ModelA is the best example with control flow.

❓ Hyperparameter

advanced

Which option correctly sets optimization for TorchScript export?

You want to export a PyTorch model with torch.jit.script and enable optimization passes. Which code snippet correctly does this?

A

scripted_model = torch.jit.script(model)
scripted_model = torch.jit.optimize_for_inference(scripted_model)

B

scripted_model = torch.jit.script(model)
torch.jit.optimize_for_inference(scripted_model)

C scripted_model = torch.jit.script(model, optimize=False)

D scripted_model = torch.jit.script(model, optimize=True)

💡 Hint

Optimization is applied after scripting using a separate function.

torch.jit.script does not take an optimize argument. Optimization is done by passing the scripted model to torch.jit.optimize_for_inference which returns an optimized model.

🔧 Debug

advanced

What error does this TorchScript export code raise?

What error will this code raise when trying to export the model with torch.jit.script?

PyTorch

import torch
import torch.nn as nn

class BuggyModel(nn.Module):
    def forward(self, x):
        y = x.numpy() + 1
        return torch.tensor(y)

model = BuggyModel()
scripted = torch.jit.script(model)

A SyntaxError: invalid syntax

B RuntimeError: Cannot convert tensor to numpy inside TorchScript

C TypeError: 'Tensor' object is not callable

D No error, exports successfully

💡 Hint

TorchScript does not allow tensor.numpy() calls inside scripted models.

Calling .numpy() on a tensor inside a scripted model is not supported and causes a runtime error during scripting.

🧠 Conceptual

expert

Why use torch.jit.trace instead of torch.jit.script for exporting a model?

Which reason best explains when torch.jit.trace is preferred over torch.jit.script for exporting PyTorch models?

A When the model is purely functional with no control flow

B When you want to optimize the model for inference automatically

C When you want to export a model without running it on example inputs

D When the model contains complex Python control flow that torch.jit.script cannot handle

💡 Hint

Tracing records operations from example inputs, ignoring control flow.

torch.jit.trace records the operations executed on example inputs and does not capture Python control flow, so it is preferred when the model has complex control flow that scripting cannot parse.

Practice

1. What is the main purpose of exporting a PyTorch model using TorchScript?

easy

A. To increase the training speed of the model

B. To save the model so it can run independently without Python

C. To convert the model into a TensorFlow format

D. To visualize the model architecture

Solution

1. Step 1: Understand TorchScript export purpose

   TorchScript export saves PyTorch models in a format that can run without Python, making deployment easier.

2. Step 2: Compare options with purpose

   Only To save the model so it can run independently without Python correctly states the main purpose: saving for standalone use without Python.

3. Final Answer:

   To save the model so it can run independently without Python -> Option B

4. Quick Check:

   TorchScript export = standalone model saving [OK]

Hint: TorchScript export = run model without Python [OK]

Common Mistakes:

• Thinking it speeds up training
• Confusing with TensorFlow conversion
• Assuming it is for visualization

2. Which of the following is the correct way to export a PyTorch model using scripting in TorchScript?

easy

A. torch.jit.trace(model, example_input)

B. torch.load('model.pt')

C. torch.save(model.state_dict(), 'model.pt')

D. torch.jit.script(model)

Solution

1. Step 1: Identify scripting syntax

   Using scripting to export a model requires torch.jit.script(model).

2. Step 2: Differentiate from tracing and saving

   torch.jit.trace(model, example_input) is tracing, torch.save(model.state_dict(), 'model.pt') saves weights only, torch.load('model.pt') loads a model, so only torch.jit.script(model) is correct for scripting export.

3. Final Answer:

   torch.jit.script(model) -> Option D

4. Quick Check:

   Scripting export uses torch.jit.script [OK]

Hint: Scripting export uses torch.jit.script(model) [OK]

Common Mistakes:

• Confusing scripting with tracing
• Using torch.save instead of torch.jit.script
• Trying to load instead of export

3. Given the code below, what will be the output of print(traced_model(torch.tensor([2.0])))?

import torch
class SimpleModel(torch.nn.Module):
    def forward(self, x):
        return x * 3

model = SimpleModel()
example_input = torch.tensor([1.0])
traced_model = torch.jit.trace(model, example_input)
print(traced_model(torch.tensor([2.0])))

medium

A. tensor([2.0])

B. tensor([3.0])

C. tensor([6.0])

D. RuntimeError

Solution

1. Step 1: Understand model behavior

   The model multiplies input by 3, so input 2.0 becomes 6.0.

2. Step 2: Check traced model output

   Tracing records the multiply by 3 operation, so traced_model(2.0) outputs tensor([6.0]).

3. Final Answer:

   tensor([6.0]) -> Option C

4. Quick Check:

   Input 2.0 * 3 = 6.0 [OK]

Hint: Model multiplies input by 3, so output is input*3 [OK]

Common Mistakes:

• Confusing input with output
• Expecting tracing to fail
• Thinking output is unchanged input

4. What is the error in the following code snippet when exporting a model with TorchScript scripting?

import torch
class MyModel(torch.nn.Module):
    def forward(self, x):
        if x.sum() > 0:
            return x * 2
        else:
            return x - 2

model = MyModel()
scripted_model = torch.jit.trace(model, torch.tensor([1.0]))

medium

A. Using torch.jit.trace instead of torch.jit.script for model with conditions

B. Missing example input tensor

C. Model class missing __init__ method

D. Incorrect tensor datatype

Solution

1. Step 1: Identify model features

   The model has a condition (if statement) in forward, which tracing cannot capture correctly.

2. Step 2: Understand TorchScript export methods

   Tracing works only for simple models without control flow; scripting is needed for conditions.

3. Final Answer:

   Using torch.jit.trace instead of torch.jit.script for model with conditions -> Option A

4. Quick Check:

   Model with conditions requires scripting, not tracing [OK]

Hint: Use scripting for models with if/else, not tracing [OK]

Common Mistakes:

• Using trace on models with control flow
• Assuming missing input tensor causes error
• Thinking __init__ is mandatory here

5. You want to export a PyTorch model that uses a loop and conditional statements inside its forward method. Which approach should you use to export it with TorchScript, and why?

hard

A. Use torch.jit.script because it supports control flow like loops and conditions

B. Use torch.jit.trace because it records operations for any model

C. Use torch.save to save the model weights only

D. Use torch.jit.trace with multiple example inputs to cover all paths

Solution

1. Step 1: Analyze model features

   The model has loops and conditions, which require TorchScript to understand control flow.

2. Step 2: Choose correct export method

   torch.jit.script compiles the model including control flow, while tracing cannot handle dynamic paths.

3. Final Answer:

   Use torch.jit.script because it supports control flow like loops and conditions -> Option A

4. Quick Check:

   Loops and conditions need scripting export [OK]

Hint: Loops and conditions require torch.jit.script export [OK]

Common Mistakes:

• Using tracing for models with dynamic control flow
• Saving weights only instead of full model
• Trying to cover all paths with tracing