Deploying Models as REST APIs

Introduction & Overview

Welcome back! So far, you have learned how to explore and prepare data, train a linear regression model, and evaluate its performance on unseen data. In the previous lesson, you saw how to use your trained model to make predictions and assess how well it generalizes to new situations. Now, it is time to take the next big step: making your model available for others to use. In real-world applications, machine learning models are rarely used only by the person who trained them. Instead, they are often deployed as web services so that other applications, websites, or users can send data and receive predictions. This is where REST APIs come in. In this lesson, you will learn how to deploy your trained model with a REST API using FastAPI . By the end of this lesson, you will know how to build, run, and test an API that serves predictions from your model, making your work accessible and useful in real-world scenarios.

Overview of REST APIs and FastAPI

Before we dive into the code, let's briefly discuss what a REST API is and why it is important in machine learning deployment. A REST API (Representational State Transfer Application Programming Interface) is a way for different software systems to communicate over the web using standard HTTP methods like GET and POST . When you deploy your model as a REST API, you make it possible for other programs to send data to your model and receive predictions in return, all through simple web requests. FastAPI is a modern Python web framework designed for building APIs quickly and efficiently. It is known for its speed, ease of use, and automatic documentation features. FastAPI also makes it easy to handle errors, which is important for building reliable machine learning services. By using FastAPI, you can create a scalable and production-ready API with minimal code.

Loading the Trained Model

The first step in building your API is to load the trained model that you saved in previous lessons. You will use the joblib library to load the model from the joblib file: Python import joblib # Load the trained model model = joblib.load('trained_model.joblib') This loads your trained linear regression model into memory so it can be used to make predictions when requests come in.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Creating the Prediction Endpoint

To handle incoming data, you can work directly with the raw JSON sent in the request. FastAPI provides access to the request body through the Request object. Here’s how you can define the prediction endpoint:

Python

from fastapi import HTTPException, Request
import pandas as pd

@app.post("/predict")
async def predict(request: Request):
    try:
        # Parse JSON body directly
        features = await request.json()
        # Convert to DataFrame
        input_data = pd.DataFrame([features])
        # Make prediction
        prediction = model.predict(input_data)[0]
        # Return a response
        return {
            "prediction": float(prediction),
            "status": "success"
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

from fastapi import HTTPException, Request
import pandas as pd

@app.post("/predict")
async def predict(request: Request):
    try:
        # Parse JSON body directly
        features = await request.json()
        # Convert to DataFrame
        input_data = pd.DataFrame([features])
        # Make prediction
        prediction = model.predict(input_data)[0]
        # Return a response
        return {
            "prediction": float(prediction),
            "status": "success"
        }
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

Let’s break down what’s happening:

The endpoint is set up at /predict, which means you (or anyone else) can send data to this specific URL to get a prediction. It accepts POST requests, which are used when you want to send data to the server for processing.
The function receives the request object, and await request.json() parses the incoming JSON body into a Python dictionary.
The features dictionary is wrapped in a list and converted into a pandas DataFrame, which is the format expected by the trained model.
The model makes a prediction, and the result is returned as a JSON response with a prediction value and a status string.
If any error occurs (such as missing fields or invalid data), an HTTP 400 error is returned with the error message.

Handling the API Response

Finally, handle the response and display the results:

Python

try:
    # Check if the request was successful (status code 200 means "OK")
    if response.status_code == 200:
        # Convert the JSON response back to a Python dictionary
        result = response.json()
        
        # Extract the prediction value from the response
        # Convert predicted value from units of 100,000s to actual dollar amount
        # (Remember: our model predicts in units of $100,000)
        predicted_value = result['prediction'] * 100000
        
        # Display the prediction in a readable format with commas and 2 decimal places
        print(f"Predicted house value: ${predicted_value:,.2f}")
        
        # Show the status from the API response
        print(f"Status: {result['status']}")
    else:
        # If status code is not 200, something went wrong
        print(f"Error: {response.status_code}")
        # Print the error message from the server
        print(response.text)
        
# Handle the specific case where we can't connect to the server
except requests.exceptions.ConnectionError:
    print(f"Error: Could not connect to API. Make sure the server is running on {url}")
# Handle any other unexpected errors
except Exception as e:
    print(f"Error: {e}")

try:
    # Check if the request was successful (status code 200 means "OK")
    if response.status_code == 200:
        # Convert the JSON response back to a Python dictionary
        result = response.json()
        
        # Extract the prediction value from the response
        # Convert predicted value from units of 100,000s to actual dollar amount
        # (Remember: our model predicts in units of $100,000)
        predicted_value = result['prediction'] * 100000
        
        # Display the prediction in a readable format with commas and 2 decimal places
        print(f"Predicted house value: ${predicted_value:,.2f}")
        
        # Show the status from the API response
        print(f"Status: {result['status']}")
    else:
        # If status code is not 200, something went wrong
        print(f"Error: {response.status_code}")
        # Print the error message from the server
        print(response.text)
        
# Handle the specific case where we can't connect to the server
except requests.exceptions.ConnectionError:
    print(f"Error: Could not connect to API. Make sure the server is running on {url}")
# Handle any other unexpected errors
except Exception as e:
    print(f"Error: {e}")

This code demonstrates proper error handling when working with APIs. The try-except block catches different types of errors that might occur: connection errors (when the server isn't running), HTTP errors (when the server returns an error status code), and general exceptions. The status code 200 indicates a successful request, while other codes like 400 (Bad Request) or 500 (Internal Server Error) indicate problems. By checking the status code and handling exceptions, your client code becomes more robust and provides helpful feedback when things go wrong.

Introduction & Overview

Overview of REST APIs and FastAPI

Loading the Trained Model

Join the 1M+ learners on CodeSignal

Creating the FastAPI Application

Creating the Prediction Endpoint

Running the API Server

Preparing the Request Data

Sending the POST Request

Handling the API Response

Observing the Results

Challenges of Local Development and SageMaker Advantages

Summary & Conclusion