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.