docs.As we all know, more and more companies struggle with a difficult Covid situation. In the following tutorial, we would like to show you a simple, and fast way to build a face mask detector app.


In the following tutorial, we will show you how to Develop, Deploy, and Integrate a Keras Face Mask Detector algorithm using Syndicai Platform. For this purpose, we will use Chandrika Deb implementation that is one of the best available on Github. The main goal of that algorithm is to detect whether a person in the picture is wearing a mask, or not. If you would like to try the state of the art of the basic object detection algorithm, check out how to deploy yolov5.

Let's start!

Step 1 | Develop

In the first phase of the tutorial, we need to prepare a model for deployment. In order to do it in the right way, the best way is to follow the checklist below.

1. Train your model

Before you start model preparation you need to be sure that your model is trained. In our case, a model is already trained so we don't have to go through that task. However, if you would like to explore object detection training workflow, please go to train yolov5 algorithm.

2. Create a Git repository

Your main model files need to be placed in a git repository. However, if you have large files (e.g. with model weights) you can store them in a separate storage or drive so that Syndicai will download them during model initialization.

In our model storing in separate storage is not necessary, because MobileNetV2 architecture is very lightweight and can be easily placed in a Github repository directly.

face mask detector reposiotry
Repository with a Face Mask Detector

3. Add & requirements.txt

In order to deploy a model with Syndicai you need to have and requirements.txt placed in your main directory. is the main file with the PythonPredictor python class responsible for model prediction. It consist of two methods __init__and predict that are necessary to properly run a model.

import os
import cv2
import numpy as np

from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
from tensorflow.keras.preprocessing.image import img_to_array
from tensorflow.keras.models import load_model

from utils import url_to_image, b64_to_image, image_to_base64

args = {
"image": "sample_data/out.jpg",
"face": "face_detector",
"model": "model/mask_detector.model",
"confidence": 0.5,

class PythonPredictor:

def __init__(self, config):
# load our serialized face detector model from disk
print("[INFO] loading face detector model...")
prototxtPath = os.path.sep.join([args["face"], "deploy.prototxt"])
weightsPath = os.path.sep.join([args["face"],
"res10_300x300_ssd_iter_140000.caffemodel"]) = cv2.dnn.readNet(prototxtPath, weightsPath)

# load the face mask detector model from disk
print("[INFO] loading face mask detector model...")
self.model = load_model(args["model"])

def predict(self, payload):

# Get image from url
image = url_to_image(payload["image_url"])
image = b64_to_image(payload["image_b64"])
orig = image.copy()
(h, w) = image.shape[:2]

# construct a blob from the image
blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300),
(104.0, 177.0, 123.0))

# pass the blob through the network and obtain the face detections
print("[INFO] computing face detections...")
detections =

# loop over the detections
for i in range(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with
# the detection
confidence = detections[0, 0, i, 2]

# filter out weak detections by ensuring the confidence is
# greater than the minimum confidence
if confidence > args["confidence"]:
# compute the (x, y)-coordinates of the bounding box for
# the object
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")

# ensure the bounding boxes fall within the dimensions of
# the frame
(startX, startY) = (max(0, startX), max(0, startY))
(endX, endY) = (min(w - 1, endX), min(h - 1, endY))

# extract the face ROI, convert it from BGR to RGB channel
# ordering, resize it to 224x224, and preprocess it
face = image[startY:endY, startX:endX]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = img_to_array(face)
face = preprocess_input(face)
face = np.expand_dims(face, axis=0)

# pass the face through the model to determine if the face
# has a mask or not
(mask, withoutMask) = self.model.predict(face)[0]

# determine the class label and color we'll use to draw
# the bounding box and text
label = "Mask" if mask > withoutMask else "No Mask"
color = (0, 255, 0) if label == "Mask" else (0, 0, 255)

# include the probability in the label
label = "{}: {:.2f}%".format(
label, max(mask, withoutMask) * 100)

# display the label and bounding box rectangle on the output
# frame
cv2.putText(image, label, (startX, startY - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 2)
image, (startX, startY), (endX, endY), color, 2)

return image_to_base64(image)d


requirements.txt – a file with all libraries and frameworks needed to recreate the model’s environment


For the Face Mask Detector, we also need other functions and files, so you can explore them in the main repository.

It is important to notice that model weights are initialized in the init method which is run only once, before the model is in the Active state.

Step 2 | Deploy

In order to deploy a model, you need connect your repo to the Syndicai Platform, so that the whole infrastructure will be created.

1. Connect a git repository

Therefore, go to Syndicai Platform and press New Model on the "Overview" page. You will be redirected to a short form. Place the URL for your model (In our case it is:

Press "Continue" and "Deploy" in the next card.

add new model in syndicai platform
When you press 'New Model' you will be redirected to a quick form to Connect a repo.

2. Wait for the Active model

Now the whole magic happens. Syndicai creates a webservice, builds a docker, and run a model on the scalable Kubernetes cluster automatically so that you don't need to care about the infrastructure setup. You can go to the Model "Builds" section to see logs from the build.

You need to have a build with status success and model with status Active.

deploy a face mask detector
When build will turn into success state you will notice that your model is Active.

Step 3 | Integrate

Congratulations, You have deployed your model!

Therefore, now you can go to the model page and Run it on the platform in the "Run a model" section. Our file was written in a way that can handle two different image input formats: URL or base64.

"image_url": ""
"image_b64": "/9j/4AAQSkZJRgABAQAAAQABA..."

You can copy one of them and paste it in the "Run a model" section.

run a face mask detector model
Paste a sample input JSON in order to run a model

When a model is working properly you can go to the "Integrate" subpage and use REST API to integrate a model with a frontend page. You can use React, or Nextjs for the frotnend page. However, you can also try our ready-made template with a Face Mask Detector showcase. The whole code for that demo page is open-source so you can fork and play with it as you like.

Closing remarks

The main goal of that tutorial was first of all to inspire you and then show that you can deploy any trained AI model in minutes. No config needed, no deep tech knowledge required - just a simple way from a model to actual use case with a click of a button.

* * *

If you found that material helpful, have some comments, or want to share some ideas for the next one - don't hesitate to drop us a line via slack or mail. We would love to hear your feedback!

You might like these

Deploy yolov5 model in a few simple clicks

February 2, 2022
Michał Zmysłowski

Train yolov5. A quick guide from a model to the actual use case.

February 2, 2022
Michał Zmysłowski