Using Your Own Custom Models

In the current release of Portal, TensorFlow and Darknet models are supported. In the event where you have another model that is built from a different machine learning library, you may consider creating a custom model class.
Datature's Engine is compatible with any type of model provided that they inherit from the BaseModel class architecture.

Creating a Custom Model

The steps to creating a custom model can be done in several steps:
From src/engine/server/models, create your own custom model module (e.g.
Import the following modules:

from import Errors, PortalError
    from import get_hash
    from server.models.abstract.BaseModel import BaseModel

Create your own custom model model class (such as ExampleModel), which inherits from BaseModel.

class ExampleModel(BaseModel):{


Within your custom model class, define the following functions:

  • load_label_map(self)
    • Converts your label map into the following dictionary format and then saves it into self.label_map:
self._label_map_ = {
            'id': 1,
            'name': 'apple',
            'id': 2,
            'name': 'pear',
  • register(self)
    • Checks if all critical files needed for loading and prediction are inside
    • Set the height (self.height) and width (self.width) of the image that the model should receive.
    • Load the label map with the function load_label_map()
    • Set the model key (self.key) to be the hash of the model directory ( with the function:
from import get_hash
self._key_ = get_hash(self._directory_)
* return (self._key_, self) as a tuple.
  • load(self)
    • Load the model into a variable and save that variable into self.model.
loaded_model = load_the_model(<model_path>)
self._model_ = loaded_model
  • predict(self, image_array)
    • Perform inference on the image array.
    • Return the inference as a dictionary of
    "detection_masks":  <ndarray of shape [Instances, Height, Width]
                        representing the prediction masks,
                        or None if this is not a segmentation model>,

    "detection_boxes":  <ndarray of shape [Instances, 4]
                        representing the bounding boxes,
                        in the form (Ymin, Xmin, Ymax, Xmax)>,

    "detection_scores": <ndarray of shape [Instances, 1]
                        representing the confidence>,

    "detection_classes": <ndarray of shape [Instances, 1],
                        representing label ids>,


The segmentation masks are in the form of image masks, not bounding box masks.


You may also define other functions, but these functions are the basic necessity.
For models that are hosted on another platform/deployed on the cloud, you may also look at Datature's API Model Script as a template for your development.

In the Model Factory src/engine/server/models/abstract/, import and add your your custom model class into the model_class dictionary.

from server.models.example_model import ExampleModel

# Inside Model function:
model_class = {
    "tensorflow": TensorflowModel,
    "darknet": DarknetModel,
    "example": ExampleModel, # <<--------- add here

The Engine is now configured to accept a new type of model. Next, we configure the App.
In the model file src/app/src/components/annotations/model.tsx:

  • In FormData -> modelType add your custom model string
export type FormData = {
  type: string;
  name: string;
  description: string;
  directory: string;
  modelKey: string;
  projectSecret: string;
  modelType: "tensorflow" | "darknet" | "example" | ""; //<----Add here
  • In Model -> render() -> modelTypes, add your custom model
const modelTypes = {
  tensorflow: "TensorFlow 2.0",
  darknet: "DarkNet (YOLO v3, YOLO v4)",
  example: "Example Model", //<-------------Add here
  • In Model -> render() -> registerModelForm, add a new Menu.Item in the Menu component
      onClick={() => {
      const event = {
          target: { name: "modelType", value: "tensorflow" },
      onClick={() => {
      const event = {
          target: { name: "modelType", value: "darknet" },
  //----------------Add below----------------------//
    onClick={() => {
      const event = { target: { name: "modelType", value: "example" } };

Now restart Portal and you should be able to see the changes!