Deploying ML Models with DRF

The Architectural Goal: From Request to Prediction

Before we write any code, let's visualize the end-to-end flow we are about to build. A client (which could be a frontend application, a mobile app, or another backend service) needs a prediction. It will send the input features for the model as a structured HTTP request to our Django server. Our Django application will then:

1. Receive the request at a specific URL endpoint.
2. Parse the incoming data.
3. Pass this data to our pre-loaded machine learning model.
4. Execute the model's predict() function.
5. Take the model's output (the prediction).
6. Format it into a JSON response and send it back to the client.

The following diagram illustrates this high-level architecture:

This diagram shows the flow we are building. The "Client" sends a "Prediction Request" to the "Django Rest End points." Our code will then use the "model Loader" and "ML Prediction algorithm" to generate a response.

Loading the Model Efficiently in Django

In the previous lesson, you loaded the model directly in a script. In a web server context, we must answer a critical question: when should we load the model? Loading a multi-megabyte model file from disk and deserializing it can take time. Doing this for every single API request would make our API incredibly slow and inefficient.

The professional standard is to load the model once when the Django application starts up and keep it in memory, ready to serve all subsequent requests. The ideal place to put this one-time loading logic is in the apps.py file of a Django app.

The article "Build a Machine Learning API With Django Rest Framework" provides a clear walkthrough of this pattern. We will adapt its approach for our project.

Creating the Prediction API View

With the model loaded, we now need to create the API endpoint that will use it. In DRF, we can use a class-based APIView to handle incoming requests. We will create a view that accepts POST requests, as clients will be sending data to us for prediction.

Inside the post method of our view, we will perform the core logic:

1. Access the incoming data from request.data.
2. Extract the features needed by our model.
3. Ensure the data is in the correct format and order that the model expects (e.g., a list or a NumPy array of numbers).
4. Call the predict() method on our globally loaded model object.
5. Package the prediction into a dictionary and return it as a DRF Response.

The same article provides a great example of this.

For a more in-depth look at this process, the "REST API Guide" by Datagraphi offers another excellent, detailed example using a different dataset. It reinforces the same core concepts of loading the model in apps.py and using it within a class-based view.

Hands-On Task: Build the Diabetes Prediction API

It's time to bring everything together. You'll continue with your Django project and integrate the diabetes prediction model from the last lesson.

Prerequisites: Ensure you have Django and Django REST Framework installed in your virtual environment.
pip install django djangorestframework scikit-learn joblib

Step 1: Organize Your Project

1. In your Django project's root directory (where manage.py is), create a new directory named ml_models.
2. Move the diabetes_model.joblib file you created in the last lesson into this new ml_models directory.
3. Create a new Django app for our predictions. From the root directory, run:
   python manage.py startapp predictions
4. Add rest_framework and your new predictions app to INSTALLED_APPS in your project's settings.py.

Step 2: Load the Model on Startup

1. Open your_project/settings.py and add the following line at the bottom to tell Django where to find your model files:

   # your_project/settings.py
   import os
   MODELS_DIR = os.path.join(BASE_DIR, 'ml_models')
   

2. Now, open predictions/apps.py and modify it to load the model.

   # predictions/apps.py
   import os
   import joblib
   from django.apps import AppConfig
   from django.conf import settings
   
   class PredictionsConfig(AppConfig):
       default_auto_field = 'django.db.models.BigAutoField'
       name = 'predictions'
       # Path to the model file
       MODEL_FILE = os.path.join(settings.MODELS_DIR, "diabetes_model.joblib")
       # Load the model
       model = joblib.load(MODEL_FILE)
   

3. In predictions/__init__.py, set the default app config:

   # predictions/__init__.py
   default_app_config = 'predictions.apps.PredictionsConfig'
   

Step 3: Create the Prediction APIView

1. Open predictions/views.py and create the view that will handle prediction requests.

   # predictions/views.py
   from rest_framework.views import APIView
   from rest_framework.response import Response
   from .apps import PredictionsConfig # Import your app's config
   
   class DiabetesPredictionAPIView(APIView):
       def post(self, request):
           # The model expects 8 features, you'll get them from the request
           # For example: ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age']
           data = request.data
           
           # Ensure the features are in the correct order
           features = [
               data.get('preg'), data.get('plas'), data.get('pres'),
               data.get('skin'), data.get('test'), data.get('mass'),
               data.get('pedi'), data.get('age')
           ]
           
           # Get the loaded model from the app config
           model = PredictionsConfig.model
           
           # Make a prediction
           # The model expects a 2D array, so we wrap our features in another list
           prediction_result = model.predict([features])
           
           # The output is an array (e.g., [1]), we take the first element
           prediction = prediction_result[0]
           
           # Create a response dictionary
           response_dict = {"prediction": "Diabetic" if prediction == 1 else "Not Diabetic"}
           
           return Response(response_dict, status=200)
   
   

*Note: This view is simplified and lacks error handling (e.g., for missing data). We will add robustness in later lessons.*

Step 4: Configure URLs

1. Create a predictions/urls.py file:

   # predictions/urls.py
   from django.urls import path
   from .views import DiabetesPredictionAPIView
   
   urlpatterns = [
       path('diabetes/', DiabetesPredictionAPIView.as_view(), name='diabetes-prediction'),
   ]
   

2. Include this new URL file in your main project's urls.py:

   # your_project/urls.py
   from django.contrib import admin
   from django.urls import path, include
   
   urlpatterns = [
       path('admin/', admin.site.urls),
       path('api/predict/', include('predictions.urls')), # Add this line
   ]
   

Step 5: Test Your API

Run your Django development server: python manage.py runserver.

Navigate to http://127.0.0.1:8000/api/predict/diabetes/ in your browser. You should see the DRF browsable API interface. Because our view only defines a post method, you'll see a message "GET method not allowed."

This is expected! Now, use the form at the bottom of the page to send a POST request. In the "Content" text area, enter your feature data in JSON format. Use the example data from the previous lesson:

{
    "preg": 6,
    "plas": 148,
    "pres": 72,
    "skin": 35,
    "test": 0,
    "mass": 33.6,
    "pedi": 0.627,
    "age": 50
}

Click "POST". If everything is set up correctly, you should receive a 200 OK response with the prediction!

Your test in the DRF browsable API should look similar to this, showing the input JSON and the JSON response containing the prediction.

Conclusion

Congratulations! You have successfully built your first machine learning API. You've taken a static, pre-trained model and exposed its functionality over the web, a foundational skill for building intelligent backend systems.

Key Takeaways:

• You can serve a machine learning model's predictions through a Django REST Framework APIView.
• For efficiency, models should be loaded once when the server starts, typically within the app's AppConfig class in apps.py.
• The API view is responsible for parsing incoming request data, transforming it into the format the model requires, calling the .predict() method, and formatting the output into a JSON Response.
• The DRF browsable API is a powerful tool for testing your endpoints directly.

This synchronous API works well for fast models. However, what if your model takes several seconds (or even minutes) to run? Making a user wait that long for an HTTP response is not a viable solution. In our next lesson, we will solve this exact problem by offloading the ML model execution to a background task using Celery, making our API responsive and robust.