[AI from Scratch] Episode 235: Creating and Publishing APIs — Providing Models as APIs

Recap and Today’s Theme

Hello! In the previous episode, we learned how to use Flask to integrate a trained model into a web application, allowing users to input data via a form and view prediction results in real-time.

Today, we will focus on creating and publishing APIs, demonstrating how to provide a machine learning model as an API. By publishing a model as an API, you can connect it with other systems and applications, making the prediction function versatile for various purposes. This episode explains how to build an API using Flask and deploy it to the internet using a cloud service like Heroku.

What Is an API?

An API (Application Programming Interface) is an interface that allows applications to communicate and exchange data with external systems or services. APIs enable different applications to interact and share functionality.

For instance, by publishing a machine learning model as an API, you can use it in the following ways:

• Web Applications: Retrieve model predictions via API and display them in a web application.
• Mobile Applications: Send data from a smartphone and get predictions through the API.
• System Integration: Integrate the prediction function with other software to automate workflows.

Basic Steps for Creating and Publishing an API

We will use Flask to build an API with a trained model, verify its functionality locally, and then deploy it online using Heroku.

1. Installing Required Libraries

First, install Flask and TensorFlow (or Keras) for building the API and loading the trained model.

pip install flask tensorflow

2. Preparing the Trained Model

Prepare the trained model for use in the API. Here’s an example of a simple classification model:

import tensorflow as tf
from tensorflow.keras import layers, models
import numpy as np

# Defining a simple model
model = models.Sequential([
    layers.Dense(128, activation='relu', input_shape=(4,)),
    layers.Dense(64, activation='relu'),
    layers.Dense(3, activation='softmax')
])

# Compiling the model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Training with dummy data
x_train = np.random.rand(100, 4)
y_train = np.random.randint(3, size=100)
model.fit(x_train, y_train, epochs=10)

# Saving the model
model.save('api_model.h5')

This model classifies data based on four features into three classes. It is saved as api_model.h5 for use in the API.

3. Building the API with Flask

Next, create a file named app.py to define the Flask application and API.

from flask import Flask, request, jsonify
import tensorflow as tf
import numpy as np

# Initializing the Flask application
app = Flask(__name__)

# Loading the trained model
model = tf.keras.models.load_model('api_model.h5')

# Defining the API endpoint
@app.route('/predict', methods=['POST'])
def predict():
    # Receiving JSON data from the client
    data = request.get_json()
    input_data = np.array(data['input']).reshape(1, -1)

    # Making a prediction using the model
    prediction = model.predict(input_data)
    predicted_class = int(np.argmax(prediction))

    # Returning the result in JSON format
    return jsonify({'prediction': predicted_class})

# Running the application
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

• /predict: Defines an endpoint that receives POST requests.
• request.get_json(): Retrieves JSON data sent by the client, which is then fed into the model.
• model.predict(): Uses the loaded model to make a prediction and returns the result as JSON.

4. Testing the API

Run the API locally using the following command:

python app.py

To test the API, use the curl command or a tool like Postman:

curl -X POST -H "Content-Type: application/json" -d '{"input": [0.1, 0.2, 0.3, 0.4]}' http://127.0.0.1:5000/predict

• -X POST: Sends a POST request.
• -H “Content-Type: application/json”: Specifies JSON format.
• -d ‘{“input”: [0.1, 0.2, 0.3, 0.4]}’: Provides the input data as four features.

If the API is set up correctly, it returns the prediction result in JSON format.

5. Publishing the API

Once the API works locally, deploy it online using Heroku. Here’s how:

(1) Install Heroku CLI

Install the Heroku CLI and log in to your account:

heroku login

(2) Prepare Files for Deployment

Prepare the following files for deployment:

1. Procfile: Specifies how to run the application on Heroku.

   web: python app.py

2. requirements.txt: Lists required libraries.

   flask
   tensorflow

3. runtime.txt: Specifies the Python version.

   python-3.9.12

(3) Deploying to Heroku

Deploy the application to Heroku using these commands:

# Create a new Heroku application
heroku create your-app-name

# Initialize a Git repository and commit files
git init
git add .
git commit -m "Initial commit"

# Add Heroku remote repository
heroku git:remote -a your-app-name

# Deploy the application
git push heroku master

Once deployed, the API is accessible via a URL like https://your-app-name.herokuapp.com/predict.

Best Practices for API Development and Deployment

1. Enhancing Security: Implement authentication and authorization to secure the API against unauthorized access.
2. Error Handling: Return appropriate error messages when input data is invalid or an error occurs during model prediction.
3. API Scaling: Use cloud services like Heroku, AWS, or GCP to configure auto-scaling based on traffic volume.
4. Caching: Implement caching to improve response times and reduce server load for repeated requests.

Summary

In this episode, we explained how to create and publish an API using Flask. We built an API with a trained model and deployed it online using Heroku. Providing machine learning models through APIs enables integration with other systems and real-time use of prediction functions. Use this as a foundation for building more complex systems and web applications.

Next Episode Preview

Next time, we will explore running models in cloud environments, covering how to operate models on platforms like AWS and GCP for scalable deployment. Let’s take the next step into cloud-based model operations!

---

Notes

• Heroku: A PaaS (Platform as a Service) that hosts applications like Python and Node.js on the cloud.
• Procfile: A configuration file that specifies how to run an application on Heroku.