FastAPI for model serving in ML Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this FastAPI endpoint code?

Consider this FastAPI code snippet that serves a simple model prediction:

from fastapi import FastAPI
app = FastAPI()

@app.get('/predict')
async def predict(x: int):
    return {'prediction': x * 2}

What will be the JSON response when a client requests /predict?x=3?

ML Python

from fastapi import FastAPI
app = FastAPI()

@app.get('/predict')
async def predict(x: int):
    return {'prediction': x * 2}

A {"prediction": 6}

B {"prediction": "6"}

C {"prediction": null}

D {"prediction": 3}

💡 Hint

Remember that the endpoint multiplies the input x by 2 and returns it as an integer in JSON.

The function receives x=3, multiplies it by 2, and returns {'prediction': 6} as JSON. The value is an integer, not a string or null.

❓ Model Choice

intermediate

Which model loading method is best for FastAPI startup?

You want to load a machine learning model once when the FastAPI app starts, so it can be reused for all requests efficiently.

Which method below correctly loads the model at startup?

A Load the model inside the endpoint function so it reloads on every request.

B Load the model globally outside any function, so it loads once when the app starts.

C Load the model inside a dependency function with <code>Depends</code> that runs per request.

D Load the model inside a background task that runs after each request.

💡 Hint

Think about how to avoid reloading the model multiple times to save time.

Loading the model globally outside functions ensures it loads once when the app starts and is reused for all requests, improving performance.

❓ Hyperparameter

advanced

Which FastAPI setting improves concurrency for model serving?

You want to serve a machine learning model with FastAPI and handle many requests at the same time efficiently.

Which Uvicorn server option helps improve concurrency?

A Use <code>--workers 4</code> to run multiple worker processes.

B Use <code>--log-level critical</code> to reduce logging overhead.

C Use <code>--reload</code> to automatically reload on code changes.

D Use <code>--workers 1</code> to keep a single process for simplicity.

💡 Hint

More workers mean more processes to handle requests concurrently.

Using multiple workers (--workers 4) runs several processes to handle requests in parallel, improving concurrency and throughput.

🔧 Debug

advanced

Why does this FastAPI model serving code raise an error?

Examine this FastAPI code snippet:

from fastapi import FastAPI
import pickle

app = FastAPI()

model = pickle.load(open('model.pkl', 'rb'))

@app.post('/predict')
async def predict(data: dict):
    features = data['features']
    prediction = model.predict([features])
    return {'prediction': prediction}

When sending a POST request with JSON {"features": [1, 2, 3]}, it raises a TypeError. Why?

ML Python

from fastapi import FastAPI
import pickle

app = FastAPI()

model = pickle.load(open('model.pkl', 'rb'))

@app.post('/predict')
async def predict(data: dict):
    features = data['features']
    prediction = model.predict([features])
    return {'prediction': prediction}

A FastAPI cannot accept POST requests with JSON bodies.

B The 'features' key is missing in the input JSON.

C pickle.load cannot load the model outside a function.

D The model.predict returns a numpy array which is not JSON serializable.

💡 Hint

Think about what type model.predict returns and how FastAPI converts it to JSON.

The model.predict method returns a numpy array, which FastAPI cannot convert to JSON directly, causing a TypeError. You need to convert it to a list first.

🧠 Conceptual

expert

What is the main advantage of using FastAPI for model serving over Flask?

Choose the best reason why FastAPI is often preferred for serving machine learning models compared to Flask.

A FastAPI requires less code to write HTML templates for web pages.

B Flask does not support JSON responses by default.

C FastAPI automatically generates interactive API docs and supports async code for better performance.

D Flask cannot be deployed on cloud platforms.

💡 Hint

Think about developer experience and performance features.

FastAPI provides automatic interactive API documentation and supports asynchronous programming, which helps handle many requests efficiently, making it ideal for model serving.