DEV Community: Idowuilekura

MLOps: Deploying Machine Learning Models with Docker and Google Cloud Platform (Part 2)

Idowuilekura — Fri, 01 Oct 2021 08:35:42 +0000

Introduction
- Model Deployment
- What on earth is Flask?
  - Getting Started with Flask
  - Getting Started with Swagger
- Deploying Machine Learning Model with Flask and Swagger
- Conclusion
- Reference/ Resources
  Introduction
  
  In the previous article, we learned about Machine Learning, the importance of Machine Learning Operations (MLOps) in the Machine Learning Lifecycle. We also learned how to frame a problem statement, gather required data, build a Machine Learning model, evaluate the model and save the model for future use.

In this article, we will look into the process of deploying a Machine Learning Model with Flask and Swagger.

Model Deployment

We have already discussed Model Deployment in the previous article, but to give a recap. Model Deployment is the process of making Machine Learning models accessible to others through different interfaces like Websites, Mobile Phones, Embedded Systems e.t.c.
Flask and Swagger will be used to deploy the model in this article, but what are Flask and Swagger?

What on earth is Flask?

According to Wikipedia

Flask is a micro web framework written in Python. It is classified as a microframework because it does not require particular tools or libraries.

Flask is simply a framework that helps python developers to build websites, without the need to learn Javascript. With flask, full-fledged websites can be built with python, HTML & CSS

Getting Started with Flask

Now that we understand the functionality of flask, let us dive into a practical example.
You will need an Integrated Development Environment like Visual Studio Code, PyCharm e.t.c to follow along. You will also need to install Flask, you can install Flask by navigating to your command prompt/terminal and type

pip install flask

Now that we have the necessary tools to work with flask, let's dive into flask. We will write a simple program that will return your name with a greeting. The code below will

Import the Flask class from the flask module
Initialize a Flask() object with the name of the current file __name__, __name__ will help python to locate where to load other dependencies into (in this case into our script). You can read this article from StackOverflow to understand the purpose of __name__
declare a variable to store my name(replace with your name)
initialize a decorator, the decorator will be called when users click on the homepage URL of the website (this is what is called when you click on www.google.com). You can read this article from Datacamp to learn more about Decorators.
define a function that binds to the decorator (the decorator will return the function whenever it is called). The function can return a HTML File or just a text.
write an if conditional statement that restricts the execution of the application to the current script(I.e if you import the script into another script the application won't run). You can read this article from GeeksForGeeks to understand the importance of if __name__== '__main__'

# Importing the Flask module from flask library
from flask import Flask

# initializing our application with the name of our module
app = Flask(__name__)
# Variable to store my name( change to your name)
my_name = 'idowu'

# Initializing the homepage route
@app.route('/')
def greet(): # function that will be returned
    return 'Hello ' + my_name

if __name__=='__main__':
    app.run(debug=True)

Copy the code above and save it inside a file, you can name the file my_flask.py . Now navigate to where you saved the file using the command line, and type python my_flask.py.

python my_flask.py

or just by clicking on the run icon if you are using Visual Studio Code.

Fig. 1 How to run python file with VSCode (Image by Author)

After running the file either with the command line/terminal or with VSCode you will be presented with this screen.

Fig. 2 Image displaying information about flask (Image by Author)

Click on the link (http://127.0.0.1:5000/),once you click on the link you will see the screen below.

Fig.3 Image showing the output of the greet function (Image by Author)

When you clicked on the link (http://127.0.0.1:5000/), flask automatically called the @app.route('/') decorator, this is because you are trying to access the homepage (which is /). The @app.route decorator will automatically call the greet function and the output of the function will be returned. You will notice that, we hardcoded the variable name into our script, which is not intuitive. What if we want to accept the name from users and return Hello + user_name,
we can do this by creating another index for the name.
We need to rewrite the programs in our script.
The code below will

Bind a welcome function to the home route (/)
Bind a different function greet_name to the /greet/name decorator. This decorator will allow users to insert their names ( this is similar to www.google.com/search/query). www.google.com is the home route url while /search is for the search route.

from flask import Flask
app = Flask(__name__)

@app.route("/")
def welcome():
    return 'Hello welcome to my first flask website'

@app.route("/greet/<name>")
def greet_name(name):
    return 'Hello ' + name

if __name__=='__main__':
    app.run(debug=True)

Delete the previous codes in my_flask.py and copy the above code into my_flask.py (ensure you save the file)

Now try to run my_flask.py and click on the homepage url.

python my_flask.py

You will be presented with the screen below

Fig. 4 Home page of the website (Image by Author)

Now, for users to insert their names, the users will need to add /greet/their_name after the homepage url i.e (http://127.0.0.1:5000/greet/their_username).

While still on the homepage, try and add /greet/your_name[replace with your name]

Fig. 5 Image showing the response from greet route

You will agree with me that this process is quite tedious. What if we have an interface that accepts responses from users using forms, sends the responses to flask and return the responses. To achieve this, we can build a form with HTML that accepts parameters. Luckily, instead of writing a HTML program, we can leverage the Swagger module to do that.

Swagger allows you to describe the structure of your APIs so that machines can read them. The ability of APIs to describe their own structure is the root of all awesomeness in Swagger. Why is it so great? Well, by reading your API’s structure, we can automatically build beautiful and interactive API documentation.
Source

Getting Started with Swagger

You will need to install flasgger module, which can be done with

pip install flasgger

The code below will

Import the request and Flask module from flask.
Import swagger from flasgger
Initialize the Flask object
Wrap the flask object application with Swagger. This helps our application to inherit properties from Swagger.
create a decorator for our homepage url
create a decorator for our greet url. If you notice we have something different from what we have been defining previously. The @app.route() decorator for the greet url takes in a methods parameter with the value Get. There are two major methods that @app.route receives
- The Get Method (The get method is used when you want to receive something, when you navigate to www.google.com you are indirectly calling the Get method to return the HTML file for the homepage)
- The Post Method is used to send information to a server. You can read this article from GeeksforGeeks to learn more about Post and Get Methods.
Inside the greet_name() function, you will have to use docstring to define the Swagger interface.
- The interface expects the;
- title of the query
- information about the query
- parameters that will be inputted. The parameter fields expects
  - the name of the field
  - the mode in which the parameter will be entered, it can be manually inserted as values(query) or by inserting a path to the value.
  - the type of the parameter ( it can be an integer or string)
  - if the parameter is compulsory or not( if it is required then the parameter can't be omitted)
- the responses.
N.B Make sure you indent the docstring with four spaces, also you will need to indent the details under the parameters and responses else swagger won't render the display.
To access the user_name under the parameters, you will need to use the request module to access the parameter
Lastly, you can return the greeting and the user_name.

Copy the code below into my_flask.py

from flask import Flask, request 
from flasgger import Swagger 
app = Flask(__name__)
Swagger(app)

@app.route("/")
def welcome():
    return 'Hello, welcome to my first flask website'


@app.route('/greet', methods=["Get"])
def greet_name():
    """Greetings
    This is using docstrings for specifications.
    ---
    parameters:
        - name: user_name
          in: query
          type: string
          required: true
    responses:
      200:
         description: "greetings with user's name"
    """

    user_name = request.args.get("user_name")

    print(user_name)

    return "Hello " + user_name

if __name__=='__main__':
    app.run(debug=True)

Now, try to run my_flask.py with

python my_flask.py

Fig. 6 Image showing the homepage (Image by Author)

To access the Swagger User Interface, append /apidocs after the homepage url i.e http://127.0.0.1:5000/apidocs

Fig. 7 Image showing the Swagger UI (Image by Author)

To interact with the UI, click on the GET button, which will present you with this screen

Fig. 8 Image showing the UI under the GET button.

If you notice, you can't insert any parameter inside the user_name, to insert value into the user_name field you will need to click on the Try it out button.

You can now insert any name into the user_name field and once you are done click on the Execute button.

Fig. 9 Image showing the Response

The response body display's the response from the greet function. Now that we have all the prerequisite for deploying our model, we can move on to cracking our main task which is to deploy a house price prediction model for Mowaale.

Deploying Machine Learning Models with Flask and Swagger

To successfully deploy the model, we will need to build a simple pipeline that will receive users inputs and make prediction.
We need to rewrite our Swagger program, to accommodate more information.
The code below will

import Flask & request from flask
import Swagger from flasgger
import joblib(this will be useful later)
load the previously saved label-encoder for sale condition and save into lb_salecond variable
load the previously saved label-encoder for sale type and save into lb_saletype variable
load the previously saved linear regression model and save into model variable
Initialize our Flask application object
Wrap the application object with Swagger
define a route for the homepage.
define another route for the predict_price index.
define the name of each parameters and other information that was discussed previously. The default is to specify a default parameter and the enum is to create a dropdown list of values.
use the request module to get each parameters that was inputted.
transform the salecondition from a string to a number (this was discussed in part 1)
transform the sale type from a string to a number.
store all the parameters into a list
use the model to make predictions and return the predicted price for the house. Copy the code below into my_flask.py

from flask import Flask, request 
from flasgger import Swagger
import joblib 
lb_salecond = joblib.load('lb_sc')
lb_saletype = joblib.load('lb_st') 
model = joblib.load('lr_model')
app = Flask(__name__)
Swagger(app)


@app.route("/")
def welcome():
    return 'Hello welcome to my first flask website'

['Normal', 'Partial', 'Abnorml', 'Family', 'Alloca', 'AdjLand']
@app.route('/predict_price', methods=["Get"])
def predict_prices():
    """Welcome to Moowale House Prediction Website
    This is using docstrings for specifications.
    ---
    parameters:
        - name: MSSubClass
          in: query
          type: integer
          required: true
        - name: LotFrontage
          in: query
          type: integer
          required: true
        - name: Year_sold
          in: query
          type: integer
          required: true
        - name: Sale_type
          in: query
          type: string
          required: true
          default: New
          enum: ['WD', 'New', 'COD', 'ConLD', 'ConLI', 'ConLw', 'CWD', 'Oth', 'Con']
        - name: Sale_condition
          in: query
          type: string
          default: Normal
          enum: ['Normal', 'Partial', 'Abnorml', 'Family', 'Alloca', 'AdjLand']
    responses:
      200:
         description: House Price Prediction
    """

    mssubclass = request.args.get("MSSubClass")
    lotfrontage = request.args.get("LotFrontage")
    year_sold = request.args.get("Year_sold")
    saletype = request.args.get("Sale_type")
    salecondition = request.args.get("Sale_condition")

    label_encode_sc = lb_salecond.transform([salecondition])
    label_encode_st = lb_saletype.transform([saletype])

    columns_list = [mssubclass,lotfrontage,year_sold,label_encode_sc,label_encode_st]

    price = round(model.predict([columns_list])[0])
    return f'The predicted price is ${price:.0f}'

if __name__=='__main__':
    app.run(debug=True)

Run my_flask.py,click on the url and attach /apidocs after the homepage url. You will see the screen below,

Fig. 10 Image showing the UI of moowale (Image by Author)

Click on Try it out, and insert these values for MSSUbClass insert 20, for Lotfrontage insert 80, for Year_sold insert 2007, for Sale type & SaleCondition leave as the default and click on Execute.

Fig.11 Image showing the prediction (Image by Author)

Now that we have our model deployed, we have come to the end of the second article in this series.

Conclusion

This article has introduced you to the process of deploying machine learning models with flask and building interactive visuals with Swagger. In part 3 of this series, you will learn how to containerize the Api with Docker and Deploy on Google Cloud Platform.
You can connect with me on Linkedin

Reference/ Resources

Video from Krish Naik channel

Flasgger

MLOps: Deploying Machine Learning models with Docker and Google Cloud Platform (Part 1)

Idowuilekura — Thu, 09 Sep 2021 19:39:15 +0000

Introduction
- MLOps Introduction
- Design Phase
  - Requirements Engineering
  - ML Use Cases and Prioritization
  - Data Availability Check
- Model Development Phase
  - Data Engineering
  - ML Model Engineering
  - Model Testing and Validation
- Operations Phase
  - ML Model Deployment
  - CI/CD Pipeline
  - Monitoring and Triggering
- Articles Focus
- Problem Statement
- Data Gathering/Data Engineering
- Model Building
- Model Evaluation
- Conclusion

Introduction

Machine Learning is the process of training machines to become intelligent and solve tasks with minimal supervision. You might be amazed at how YouTube intelligently recommends videos for you or how Spotify magically suggests new songs to you. What powers the intelligent recommendation or magically suggested songs is simply machine learning. Humans learned how to walk by observing how others walked and tried to replicate the process. Similarly, machines learn to perform tasks by iteratively following the patterns in a given dataset and then forming a mathematical function. Data scientists can use the mathematical function to make predictions on new datasets. As shown in the image below, training datasets are fed into the machine learning model. The model learns the patterns and develops a mathematical function (h). The mathematical function is then applied to a new dataset to make predictions. You can read this article to gain a better understanding of machine learning.

Fig.1 How machine learning works source

### MLOps Introduction
The Youtube recommendation model was built and then deployed on Youtube for users to enjoy. Imagine if Google built the recommendation model without deploying it on Youtube? That would be awkward, and we wouldn't be able to enjoy Youtube recommendations today. Unfortunately, most data scientists are comfortable with just building models without deploying them to production for end-users to enjoy. Machine Learning Operations (MLOps) is simply the process of shipping your machine learning models to production (this is just a basic definition). According to Wikipedia MLOps is

MLOps is a set of practices that aims to deploy and maintain machine learning models in production reliably and efficiently.

As shown in the image below, MLOps is an iterative method, that encompasses the:

Design Phase
Model Development Phase
Operations Phase

Fig.2 MLOps Phases source

Design Phase

Under the Design Phase we have other sub-phases, which are:

Requirement Engineering
ML Use-Cases and Prioritization
Data Availability Check

Requirements Engineering

According to Javatpoint

Requirements Engineering (RE) refers to the process of defining, documenting, and maintaining requirements in the engineering design process.

Requirement engineering helps an individual/ company understand the desires of the customers. It involves understanding the customers' needs through analysis, assessing the feasibility of a solution/product, settling for a better solution, clearly framing the solution, validating the specifications, managing any requirements before transforming it into a working system.

Fig.3 Requirement Engineering Process source

The first step in any Data Science/ Machine learning lifecycle is requirement engineering. This phase is where you understand your customers' needs. For instance, Spotify was able to build a recommendation model because this is what most customers need. You can read more about requirements engineering here

ML Use Cases and Prioritization

This phase is where Machine Learning practitioners prioritize the impact of any proposed machine learning solution on their business. This phase is concerned with analyzing the importance of a proposed machine learning solution towards their goals. The truth is some proposed machine learning solutions aren't profitable to an organization. In this phase, companies drop those solutions.
You can read this article from Srivatsan Srinivasan,a Google Developer Expert; the report will give you more understanding of prioritizing Machine Learning Use Cases.

Data Availability Check

This phase deals with the process of checking if there are available datasets to train the model. You can't train any machine learning model without data

Model Development Phase

The model development phase encompasses these sub-phases;

Data Engineering
ML Model Engineering
Model Testing and Validation

Data Engineering

The Data Engineering phase deals with collecting relevant datasets that will be used to train the model. Data validation is also carried out here; this ensures that the data is valid and clean. If you feed poor data into a sophisticated model, you will get a poor result. You can read this article to learn more about data engineering

ML Model Engineering

The model engineering phase deals with training the model with the data, performing feature engineering. Data Scientist/Machine Learning engineers sometimes try out other models, stack up two or more models together at this phase.

Model Testing and Validation

After you have trained your model, there is a need to test and evaluate the model's performance. You wouldn't want to deploy a model that is performing terribly on unseen data. The model testing and Validation phase deals with testing and evaluating the model on unseen data. While the model might perform better on the training dataset, you want to make sure that the model also performs well on an unseen dataset(test).
Different metrics can be used to evaluate your model; if you are working on a regression task, you can use mean squared error, mean absolute error, e.t.c, while working on classification tasks, you can use accuracy, f1 score, recall, precision e.t.c.

Operations Phase

Ml model deployment, CI/CD Pipelines and Monitoring & Triggering
Under the operations phase, we have these sub-phases;

ML Model Deployment
CI/CD Pipelines
Monitoring and Triggering

ML Model Deployment

This phase deals with deploying the model to production; the production environment can be a website, mobile phones, or edge computing devices like embedded systems.

CI/CD Pipeline

CI/CD means Continuous Integration and Continuous Deployment. CI/CD is a set of practices that enables developers to change codes and deliver the code to production frequently and safely. CI/CD helps data scientists/ machine learning engineers continuously make changes to their model training, testing the newly trained model and deploying it frequently and safely. You can read this article to learn more about CI/CD

Monitoring and Triggering

This phase involves monitoring the model's performance in the production environment, triggering the CI/CD pipeline if the model performance drops below a threshold. The performance of a machine learning model can reduce due to changes in the production datasets; there can be a difference in the data used to train the model and data fed into the model during predictions in the production environment.

If the model performance falls below a certain threshold, then the model needs to be retrained and redeployed; the model retraining is done by triggering the CI/CD pipeline.

Articles Focus

The focus of the articles in this series is on building a machine learning model and deploying the model with Docker and Google Cloud Platform.

Machine Learning models are built to solve problems; hence, a problem statement needs to be defined before building any machine learning model.

Problem Statement

You just resumed as a data scientist at moowale; moowale is a real estate company that lists houses for sale. You have been tasked with building a machine learning model that can be used to predict the price of any building based on some given parameters. The model will be deployed to make it easy for customers to get predicted prices based on information they input into the moowale website.

N.B moowale is a Yoruba word meaning I am searching for a house [to buy].

Data Gathering/Data Engineering

Now that you have a well-defined problem statement, the next stage is to gather the data used to train the model. You can source datasets from public dataset repositories or talk to the data engineer to deliver the needed dataset to you. An existing dataset can be used to train the model; the house price prediction dataset on Kaggle will be used to train the model. You can access the dataset with this link; the train.csv dataset will be used to train the model.

Model Building

It's time to build our model, but we will need to explore the dataset (exploratory data analysis). To follow along, you will need to have an Integrated Development Environment like Jupyter Notebook/Lab (which most data scientists use). You can learn more about Jupyter Notebooks with this link.
Now that you have Jupyter Notebook, you can open it and follow along.
To explore the dataset, we will be using some python libraries, which we will import.

# importing necessary libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

Pandas will be used to read the dataset, NumPy is a numerical module, matplotlib is a plotting module and %matplotlib inline helps Jupyter notebook render plots within the notebook.

Now that the necessary modules have been imported, the next step is to load and visualize the dataset.

# reading the dataset with pandas
dataset = pd.read("train.csv")

# Exploring the first five rows
data.head()

Fig. 4 Image of the first five rows of the dataset (Image by Author)

# printing the number of columns
print(f"There are {len(data.columns)} columns in the dataset")

Fig. 5 Printing the number of columns in the dataset (Image by Author)

There are 81 columns(or features) in the dataset; not all are useful for model building. You will need to rely on picking the necessary columns to be used to train the model. Data scientist either relies on domain knowledge gained from experience or consulting with a domain expert in the field of interest to choose valuable columns. For this task, I will just pick columns based on assumptions. Columns that will be chosen are 'MSSubClass',"LotFrontage','YrSold','SaleType','SaleCondition','SalePrice

data_new = data[['MSSubClass','LotFrontage','YrSold','SaleType','SaleCondition','SalePrice']]

# checking for missing values
data_new.info()

Fig. 5 Information about the dataset. (Image by Author)

The LotFrontage has missing values; since the column is of float datatype, the missing values can be filled with the column mean, column median, or a constant number.

# Filling with a constant number
data_new['LotFrontage'] = data_new['LotFrontage'].fillna(-9999)

# check for missing values again
data_new.info()

There are no more missing values, the next phases is model building.

Looking closely at the data_new.info() result, you will notice that we have two columns with object data type.
Machine Learning models expect all columns to be in numerical format, hence converting the columns to numeric. LabelEncoder is widely used to convert categorical columns to numeric columns; you can read more about LabelEncoder here

# using label encoder to encode the categorical columns
from sklearn.preprocessing import LabelEncoder, StandardScaler

# saletype label encoder
lb_st = LabelEncoder()
# salecondition label encoder
lb_sc = LabelEncoder()

lb_st.fit(data_new['SaleType'])
lb_sc.fit(data_new['SaleCondition'])

data_new['SaleType'] = lb_st.transform(data_new['SaleType'])
data_new["SaleCondition"] = lb_sc.transform(data_new['SaleCondition'])

The .fit() method encodes each category to a number, and the .transform() method transforms the category to number (you need to fit before you can transform).

Now that all columns are in numerical format, it's time to build the machine learning model. Machine Learning Engineers/ Data scientists usually split the dataset into train and test sets (the train set is used to train the model while the test set is used to evaluate the model's performance). To split the dataset into train and test, the features used to train the model must be separated from the target.

# Separating the dataset into features(X) and target(y)
X = data_new.drop("SalePrice",axis=1)
y = data_new['SalePrice']

The features are named X, and the target is named y because machine learning is basically mathematical functions applied to data. Recall from mathematics that *f*X= y, the target(y) is computed by applying a mathematical function on your features (X) (this is what happens in machine learning or during model training).

# splitting the dataset into train and test set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train,y_test = train_test_split(X,y)

Now that we have our train and test dataset, it's time to build our model. There are two significant types of machine learning tasks, Classification and Regression. Regression deals with numerical targets, while classification deals with categorical targets.
The target is SalePrice which is numerical; hence a regression model will be used.
There are different regression models; Linear Regression is the simplest to understand and beginner-friendly regression model. LinearRegression model will be used in this project to keep it simple); you can use other regression models like RandomForestRegressor etc.

from sklearn.linear_model import LinearRegression

lr = LinearRegression()

# training the model
lr.fit(X_train,y_train)

Model Evaluation

Recall that after building your model, you need to evaluate the performance of the model. Several metrics can be used to evaluate machine learning models; for regression models, metrics include mean squared error, mean absolute error, root mean squared error e.t.c. Root Mean Squared Error metric will be used to evaluate the model.

from sklearn.metrics import mean_squared_error

np.sqrt(mean_squared_error(lr.predict(X_test),y_test))

# this will give approximately 73038

The Root Mean Squared Error is quite large; machine learning engineers/ data scientists tries to reduce the error by trying other models and applying feature engineering. I won't be diving into that; the article's aim is not to minimize the error.

Now that we have our model, to use the model in production, you will need to save the model and the two label encoder that was initialized earlier.

# joblib is for saving objects for later use
import joblib
joblib.dump(lr,'lr_model')

joblib.dump(lb_sc,'lb_sc')

joblib.dump(lb_st,'lb_st')

joblib.dump() accepts two default parameters: the object you want to save and the name you wish to save the object with.

Now that we have our model saved, we have finally come to the end of the first article in this series.

Conclusion

This article has introduced you to machine learning, the importance of machine learning operation in the Machine Learning Lifecycle. How to frame a problem statement, gather data, build a linear regression model, evaluate the model and finally save the model for future use. In Part2 of this series, you will learn how to build machine learning APIs with flask, test the APIs and containerize the API with Docker.