REST API inference in PyTorch - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is REST API inference in machine learning?

REST API inference means using a web service to send data to a machine learning model and get predictions back over the internet.

beginner

Why do we use REST APIs for model inference?

REST APIs let different programs talk to the model easily, no matter where they run, making it simple to get predictions from anywhere.

intermediate

In PyTorch, what is the typical step before serving a model via REST API?

You load the trained model, set it to evaluation mode with model.eval(), and prepare it to receive input data for prediction.

beginner

What HTTP method is commonly used to send data for inference in REST APIs?

POST is commonly used because it allows sending data in the request body to the server for prediction.

intermediate

How do you ensure the REST API inference is fast and responsive?

By loading the model once, using efficient data processing, and avoiding reloading the model on every request.

Which HTTP method is best for sending input data to a REST API for inference?

A POST

B GET

C DELETE

D PUT

POST is used to send data in the request body, which is needed for inference input.

In PyTorch, what does model.eval() do before inference?

A Switches the model to training mode

B Switches the model to evaluation mode

C Deletes the model

D Saves the model

model.eval() sets the model to evaluation mode, disabling training-specific features like dropout.

What is the main advantage of using a REST API for model inference?

A It allows remote access to the model predictions

B It stores the model data

C It trains the model automatically

D It makes the model run faster

REST APIs let clients send data and get predictions from the model remotely.

Which format is commonly used to send data in REST API requests for inference?

A CSV

B XML

C JSON

D Plain text

JSON is widely used because it is easy to read and parse for sending structured data.

What should you avoid to keep REST API inference fast?

A Loading the model once at startup

B Using batch predictions

C Preprocessing input data efficiently

D Reloading the model on every request

Reloading the model on every request wastes time and slows down inference.

Explain how a REST API can be used to get predictions from a PyTorch model.

Think about how data travels from client to server and back.

Describe the steps to prepare a PyTorch model for REST API inference.

Focus on what happens before and during the API call.

Practice

1. What is the main purpose of using a REST API for PyTorch model inference?

easy

A. To train the model faster using multiple GPUs

B. To send data to the model and receive predictions over the web

C. To visualize the model architecture in a browser

D. To save the model weights to disk

Solution

1. Step 1: Understand REST API role

   A REST API allows communication over the web by sending requests and receiving responses.

2. Step 2: Connect REST API with model inference

   In PyTorch, a REST API is used to send input data and get predictions from the model remotely.

3. Final Answer:

   To send data to the model and receive predictions over the web -> Option B

4. Quick Check:

   REST API = Web data exchange for predictions [OK]

Hint: REST API = send input, get prediction over web [OK]

Common Mistakes:

• Confusing inference with training
• Thinking REST API is for saving models
• Assuming REST API visualizes models

2. Which of the following is the correct way to disable gradient calculation during inference in a Flask REST API using PyTorch?

easy

A. with torch.no_grad():

B. model.train()

C. torch.enable_grad()

D. model.backward()

Solution

1. Step 1: Identify how to disable gradients

   PyTorch uses torch.no_grad() context to turn off gradient tracking during inference.

2. Step 2: Check other options

   model.train() enables training mode, torch.enable_grad() enables gradients, and model.backward() is invalid.

3. Final Answer:

   with torch.no_grad(): -> Option A

4. Quick Check:

   Disable gradients = torch.no_grad() [OK]

Hint: Use torch.no_grad() to save memory during inference [OK]

Common Mistakes:

• Using model.train() instead of model.eval()
• Not disabling gradients causing slow inference
• Calling backward() during inference

3. Given this Flask route for inference, what will be the output if the input JSON is {'input': [1.0, 2.0]} and the model returns tensor([3.0])?

from flask import Flask, request, jsonify
import torch
app = Flask(__name__)
model = torch.nn.Linear(2, 1)
model.eval()

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    x = torch.tensor(data['input']).unsqueeze(0).float()
    with torch.no_grad():
        output = model(x)
    return jsonify({'prediction': output.item()})

medium

A. {"prediction": "tensor([3.0])"}

B. {"prediction": [3.0]}

C. Error: model not loaded

D. {"prediction": 3.0}

Solution

1. Step 1: Understand input and output processing

   The input JSON is converted to a tensor with shape (1, 2). The model outputs a tensor with shape (1, 1).

2. Step 2: Check output conversion

   The output tensor's single value is extracted using output.item(), which returns a float, then wrapped in JSON.

3. Final Answer:

   {"prediction": 3.0} -> Option D

4. Quick Check:

   output.item() returns float for JSON [OK]

Hint: Use output.item() to get scalar from tensor for JSON [OK]

Common Mistakes:

• Returning tensor object directly in JSON
• Forgetting to convert input to tensor
• Not using torch.no_grad() causing slow inference

4. You wrote this Flask REST API code for inference but get an error: 'RuntimeError: expected scalar type Float but found Double'. What is the likely fix?

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    x = torch.tensor(data['input'])
    with torch.no_grad():
        output = model(x)
    return jsonify({'prediction': output.item()})

medium

A. Convert input tensor to float using .float() before passing to model

B. Call model.train() before inference

C. Remove torch.no_grad() context

D. Change model output to int

Solution

1. Step 1: Understand the error cause

   The model expects float tensors but input tensor is double (default from Python floats).

2. Step 2: Fix input tensor type

   Convert input tensor to float type using .float() before passing to the model.

3. Final Answer:

   Convert input tensor to float using .float() before passing to model -> Option A

4. Quick Check:

   Tensor dtype mismatch fixed by .float() [OK]

Hint: Always convert input to float tensor before model call [OK]

Common Mistakes:

• Not converting input data type
• Calling model.train() during inference
• Removing torch.no_grad() causing slow inference

5. You want to deploy a PyTorch model as a REST API that accepts images, preprocesses them, and returns class predictions. Which sequence of steps is best practice inside your Flask route?

hard

A. Load model globally, call model.eval(), preprocess input image to numpy array, call model backward(), return JSON

B. Load model inside route on every request, call model.train(), preprocess input, get prediction, return JSON

C. Load model once globally, set model.eval(), preprocess input image to tensor, use torch.no_grad(), get prediction, return JSON

D. Preprocess input image after prediction, load model globally, call torch.enable_grad(), return raw tensor

Solution

1. Step 1: Model loading and mode

   Load the model once globally to avoid overhead and set it to evaluation mode with model.eval().

2. Step 2: Input preprocessing and inference

   Preprocess the input image to a tensor, use torch.no_grad() to disable gradients, get prediction, and return JSON response.

3. Final Answer:

   Load model once globally, set model.eval(), preprocess input image to tensor, use torch.no_grad(), get prediction, return JSON -> Option C

4. Quick Check:

   Efficient inference = global load + eval + no_grad + preprocess [OK]

Hint: Load model once, eval mode, no_grad, preprocess input tensor [OK]

Common Mistakes:

• Loading model on every request causing slow response
• Using model.train() during inference
• Not preprocessing input to tensor
• Calling backward() during inference