SeeMe.ai Python SDK #

The Python SDK is a convenient wrapper to communicate with the SeeMe.ai API and gives easy access to all of your datasets, models, jobs, … on the platform.

This document provides a detailed overview of all the methods and their parameters.

Installation #

Install the SDK from the command line:

$ pip install seeme

Verfiy the version you have installed:

!pip install --upgrade seeme

import seeme
seeme.__version__

Create a client #

Create a client to interact with the SeeMe.ai API, allowing you to manage models, datasets, predictions and jobs.

from seeme import Client

client = Client()

If you have a username and apikey, you can create a client that is ready to go:

my_username = ""
my_apikey = ""

client = Client(username=my_username, apikey=my_apikey)

parameters:

• username (optional) : the username for the account you want to use;
• apikey (optional): the API key for the username you want user;
• backend (default provided): the backend the client communicates with, default: https://api.seeme.ai/api/v1.

Advanced: create a client that talks to a custom backend:

alternative_url = ""

client = Client(backend=alternative_url)

# or with auth
# client = sm.Client(username=my_username, apikey=my_apikey, backend=alternative_url)

Register #

Register a new user:

my_username = "my_username"
my_email = "myname@mydomain.com"
my_password = "supersecurepassword"
my_firstname = "first name"
my_name = "last name"

client.register(
    username=my_username, 
    email=my_email, 
    password=my_password, 
    firstname=my_firstname, 
    name=my_name
)

Log in #

username = ""
password = ""

client.login(username, password)

Log out #

client.logout()

Models #

Get all models #

Get a list of all models you have access to.

models = client.get_models()

These models are divided in three groups:

• public: models that are available to everyone;
• owned: models you created;
• shared: models that are shared privately with you.

Public models

Public models are available for everyone.

public_models = [model for model in models if model["public"]]

Your own models

A list of the models you created:

own_models = [ model for model in models if model["user_id"] == client.user_id]

Shared models

A list of models that others have shared with you in private.

shared_with_me = [model for model in models if model["shared_with_me"]]

Create a model #

my_model = {
    "name": "Cats and dogs",
    "description": "Recognize cats and dogs in pictures."
}

my_model = client.create_model(my_model)

Every model has the following properties:

{
    'id': '22791060-71f5-4e71-935e-28b52ef4c047',
     'created_at': '2021-10-28T08:49:06.698391719Z',
     'updated_at': '2021-10-28T08:49:06.698391719Z',
     'name': 'Cats and dogs',
     'description': 'Recognize cats and dogs in pictures.',
     'active_version_id': 'fc92b1fe-2ee0-4d99-9a09-0a37d0c68ea1',
     'classes': '',
     'accuracy': 0,
     'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
     'can_inference': False,
     'kind': '',
     'has_logo': False,
     'logo': '',
     'public': False,
     'config': '',
     'application_id': '',
     'has_ml_model': False,
     'has_onnx_model': False,
     'has_tflite_model': False,
     'has_labels_file': False,
     'shared_with_me': False,
     'auto_convert': True,
     'privacy_enabled': False
 }

Properties in more detail:

# DEPRECATED
# just calls `create_model` underneath
my_model = client.create_full_model(my_model)

Get a model #

Use the model id to get all the metadata of the model:

client.get_model(my_model["id"])

Update a model #

Update any property of the model:

my_model["description"] = "Updated for documentation purposes"

client.update_model(my_model)

Delete a model #

Delete a model using its id.

client.delete_model(my_model["id"])

Upload a model file #

You can upload the model file by calling the upload_model. Make sure the application_id is set to the desired AI application, framework, and version.

my_model = client.upload_model(my_model["id"], folder="directory/to/model", filename="your_exported_model_file.extension")

This returns an updated my_model, where if successful the can_inference should now be set to True.

If auto_convert is enabled and depending on the used application_id (see Applications below), the model will have updated values for has_ml_model, has_tflite_model, has_onnx_model, has_labels_file.

Download model file(s) #

Download the file(s) associated with the current active (production) model.

client.download_active_model(my_model, asset_type="pkl", download_folder="my_project")

If the asset_type exists, the model file will be downloaded to my_model["active_model_id"].{asset_type}. One exception, the labels file will receive a .txt extension.

Make a prediction #

result = client.predict(model_id, item, input_type="image_classification")

Image classification #

On an image classification model:

item = "path/to/file.png"

result = client.predict(my_model["id"], item)

# Or
# result = client.predict(my_model["id"], item, input_type="image_classification")

Object detection #

On an object detection model:

item = "path/to/file.png"

result = client.predict(my_model["id"], item, input_type="object_detection")

Text classification #

On a text classification model:

item = "The text you want to classify."

result = client.predict(my_model["id"], item, input_type="text_classification")

Named entity recognition #

On a text named entity recognition model:

item = "The text where I want to extract information out of."

result = client.predict(my_model["id"], item, input_type="ner")

Language model #

On a language model:

item = "The story of AI language models is"

result = client.predict(my_model["id"], item, input_type="langauge_model")

Tabular #

On a structured/tabular data model:

import json

inputs = {
    "temperature": "30",
    "day": "Tuesday"
}

item = json.dumps(inputs)

result = client.predict(my_model["id"], item, input_type="structured")

An example reply for a prediction:

{
    'id': '891ed37a-fe77-415c-a4ab-3764e68aaa40',
    'created_at': '2021-10-28T12:33:17.277236872Z',
    'update_at': '2021-10-28T12:33:17.563600762Z',d
    'name': '10789.jpg',
    'description': '',
    'prediction': 'cats',
    'confidence': 0.9846015,
    'model_id': '56086c08-c552-4159-aafa-ac4b25a64fda',
    'model_version_id': '1a38b7ab-070f-4686-9a47-4ba7a76a5168',
    'extension': 'jpg',
    'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
    'error_reported': False,
    'error': '',
    'application_id': 'b4b9aaf0-cb37-4629-8f9b-8877aeb09a53',
    'inference_host': 'image-pt-1-8-1-fa-2-3-1',
    'inference_time': '284.418389ms',
    'end_to_end_time': '',
    'dataset_item_id': '',
    'result': '',
    'inference_items': None,
    'hidden': False,
    'privacy_enabled': False
 }

Properties in more detail:

# DEPRECATED
# Used internally by `predict` but will be removed.
result = client.inference(my_model["id"], item, input_type="image_classification")

Upload model logo #

my_model = client.upload_logo(my_model["id"], folder="directory/to/logo", filename="logo_filename.jpg")

Download model logo #

client.get_logo(my_model)

Model Versions #

An AI Model has one or multiple versions associated with it:

• the current live (“active”) version
• previous versions
• future versions

While AI models, frameworks, and framework versions evolve and emerge, your AI model will be able to easily benefit from these evolutions over time.

Get all model versions #

Get a list of all versions for a specific model.

versions = client.get_model_versions(my_model["id"])

Create a model version #

new_version = {
    "name": "A higher accuracy achieved",
    "application_id": "b4b9aaf0-cb37-4629-8f9b-8877aeb09a53"
}

new_version = client.create_model_version(my_model["id"], new_version)

Every model version has the following properties. Note that these are partially similar to the model properties:

{
    'id': '53535e2f-4b36-4235-b8d6-ed87a5d2f323',
    'created_at': '2021-10-29T14:16:46.603463402Z',
    'update_at': '2021-10-29T14:16:46.603463402Z',
    'name': 'A higher accuracy achieved',
    'description': '',
    'model_id': '22791060-71f5-4e71-935e-28b52ef4c047',
    'classes': '',
    'accuracy': 0,
    'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
    'can_inference': False,
    'has_logo': False,
    'logo': '',
    'config': '',
    'application_id': '878aea66-16b7-4f10-9d82-a2a92a35728a',
    'version': '',
    'version_number': 4,
    'has_ml_model': False,
    'has_onnx_model': False,
    'has_tflite_model': False,
    'has_labels_file': False,
    'dataset_version_id': '',
    'job_id': ''
}

Properties in more detail.

Shared with the model entity:

Different from the model entity.

Get model version #

Use the model and version id to get the full model version:

model_version = client.get_model_version(my_model["id"], new_version["id"])

Update model version #

Update any property of the model version:

model_version["description"] = "We hit SOTA!"

client.update_model_version(model_version)

Upload model file for a version #

Upload a model file (or model files) for a new version of your AI model.

Make sure the application_id is set to the desired AI application, framework, and version.

client.upload_model_version(new_version, folder="directory/to/model", filename="your_exported_model_file_v2.pkl")

Download a specific version #

client.download_model(my_version, asset_type="pkl", download_folder="data")

If the asset_type exists, the model file will be downloaded to my_model["active_model_id"].{asset_type}. One exception, the labels file will receive a .txt extension.

# DEPRECATED
client.download_version(my_version, asset_type="pkl")

Make a prediction on this version #

client.version_inference(model_version_id, item, input_type="image_classification")

Image classification #

On an image classification model version:

item = "path/to/file.png"

result = client.version_inference(new_version["id"], item)

# Or
# result = client.version_inference(new_version["id"], item, input_type="image_classification")

Object detection #

On an object detection model version:

item = "path/to/file.png"

result = client.version_inference(new_version["id"], item, input_type="object_detection")

Text classification #

On a text classification model version:

item = "The text you want to classify."

result = client.version_inference(new_version["id"], item, input_type="text_classification")

Tabular #

On a strctured/tabular data model version:

import json

inputs = {
    "temperature": "30",
    "day": "Tuesday"
}

item = json.dumps(inputs)

result = client.version_inference(my_model["id"], item, input_type="structured")

An example reply for a prediction:

{
    'id': '891ed37a-fe77-415c-a4ab-3764e68aaa40',
    'created_at': '2021-10-28T12:33:17.277236872Z',
    'update_at': '2021-10-28T12:33:17.563600762Z',d
    'name': '10789.jpg',
    'description': '',
    'prediction': 'cats',
    'confidence': 0.9846015,
    'model_id': '56086c08-c552-4159-aafa-ac4b25a64fda',
    'model_version_id': '1a38b7ab-070f-4686-9a47-4ba7a76a5168',
    'extension': 'jpg',
    'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
    'error_reported': False,
    'error': '',
    'application_id': 'b4b9aaf0-cb37-4629-8f9b-8877aeb09a53',
    'inference_host': 'image-pt-1-8-1-fa-2-3-1',
    'inference_time': '284.418389ms',
    'end_to_end_time': '',
    'dataset_item_id': '',
    'result': '',
    'inference_items': None,
    'hidden': False,
    'privacy_enabled': False
 }

Properties in more detail:

# DEPRECATED
# Used internally by `version_inference` but will be removed.
result = client.version_p(my_model["id"], item, input_type="image_classification")

Activate your model #

When uploaded, model versions are instantly available to try and shadow production. When you are ready to active a new model version to all your users, you can set the ‘active_model_id’ on the main model object.

Once your model is updated, all users benefit from the new version, with zero downtime.

my_model["acitve_model_id"] = new_version["id"]
client.update_model(my_model)

Delete model version #

Delete a model version:

client.delete_model_version(my_model["id"], new_version["id"])

Datasets #

Easily create, update, version, and manage datasets for your AI models.

Get all datasets #

Get a list of all your datasets:

datasets = client.get_datasets()

These datasets are divided in three groups:

• public: datasets that are available to everyone;
• owned: datasets you created;
• shared: datasets that are shared privately with you.

Public datasets

Public datasets are available for everyone.

public_datasets = [dataset for dataset in datasets if dataset["public"]]

Your own datasets

A list of the datasets you created:

own_datasets = [ dataset for dataset in datasets if dataset["user_id"] == client.user_id]

Shared datasets

A list of datasets that others have shared with you in private.

shared_with_me = [dataset for dataset in datasets if dataset["shared_with_me"]]

Create a dataset #

from seeme import DATASET_CONTENT_TYPE_IMAGES

my_dataset = {
    "name": "Cats & dogs dataset",
    "description": "A dataset with labelled images of cats and dogs.",
    "multi_label": False,
    "notes": "Cats and dogs is often used as a demo dataset.",
    "default_splits": True,
    "content_type": DATASET_CONTENT_TYPE_IMAGES
}

my_dataset = client.create_dataset(my_dataset)

my_dataset

Every dataset has the following properties:

{
    'id': '2bb8b9c1-c027-44c2-b438-6d50911964bd',
    'created_at': '2021-11-02T10:52:56.386712086Z',
    'update_at': '2021-11-02T10:52:56.386712086Z',
    'deleted_at': None,
    'name': 'Cats & dogs dataset',
    'description': 'A dataset with labelled images of cats and dogs.',
    'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
    'notes': 'Cats and dogs is often used as a demo dataset.',
    'versions': [],
    'multi_label': False,
    'default_splits': True,
    'has_logo': False,
    'logo': '',
    'content_type': 'images'
}

Properties in more detail:

Get dataset #

my_dataset = client.get_dataset(my_dataset["id"])

Update dataset #

my_dataset["notes"] += "~25k labelled images of cats and dogs; 22500 for training, 2000 for validation."

client.update_dataset(my_dataset)

Delete dataset #

client.delete_dataset(my_dataset)

Upload dataset logo #

my_dataset = client.upload_dataset_logo(my_dataset["id"], folder="directory/to/logo", filename="logo_filename.jpg")

Download dataset logo #

client.get_dataset_logo(my_dataset)

Dataset Versions #

A dataset can have multiple versions.

Get all dataset versions #

dataset_versions = client.get_dataset_versions(my_dataset["id"])

Create dataset version #

new_dataset_version = {
    "name": "v2",
    "description": "Even more images of dogs and cats"
}

new_dataset_version = client.create_dataset_version(my_dataset["id"], new_dataset_version)

new_dataset_version

Every dataset_version has the following properties:

{
    'id': 'd774d5bd-40fd-4c5f-8043-f1a8ed88e0d2',
    'created_at': '2021-11-02T13:17:29.24027517Z',
    'update_at': '2021-11-02T13:17:29.24027517Z',
    'name': 'v2',
    'description': 'Even more images of dogs and cats',
    'labels': None,
    'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
    'dataset_id': '2bb8b9c1-c027-44c2-b438-6d50911964bd',
    'splits': None,
    'default_split': '',
    'config': ''
}

Properties in more detail:

Get a dataset version #

dataset_version = client.get_dataset_version(new_dataset_version["dataset_id"], new_dataset_version["id"])

Update a dataset version #

new_dataset_version["description"] = "Even more image of cats and dogs."

client.update_dataset_version(my_dataset["id"], new_dataset_version)

Delete a dataset version #

client.delete_dataset_version(my_dataset["id"], new_dataset_version)

Dataset Splits #

A dataset version can have multiple splits, usually separating training, validation and test data.

Get all splits #

splits = client.get_dataset_splits(my_dataset["id"], new_dataset_version["id"])

Create a split #

new_split = {
    "name": "train",
    "description": "training data for our model to learn from" 
}

new_split = client.create_dataset_split(my_dataset["id"], new_dataset_version["id"], new_split)

Every dataset split has the following properties:

{
    'id': '3faa6ddb-f5d6-4dda-92a9-beb383126072',
    'created_at': '2021-11-02T14:02:15.303555455Z',
    'updated_at': '2021-11-02T14:02:15.303555455Z',
    'name': 'train',
    'description': 'training data for our model to learn from',
    'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
    'version_id': 'd774d5bd-40fd-4c5f-8043-f1a8ed88e0d2'
}
 

Properties in more detail:

Get a split #

my_split = client.get_dataset_split(my_dataset["id"], new_dataset_version["id"], new_split["id"])

Update a split #

my_split["description"] = "Training data"

client.update_dataset_split(my_dataset["id"], new_dataset_version["id"], my_split)

Delete a split #

client.delete_dataset_split(my_dataset["id"], new_dataset_version["id"], my_split)

Dataset Labels #

A dataset version can have multiple labels.

Get all labels #

labels = client.get_dataset_labels(my_dataset["id"], new_dataset_version["id"])

labels

Create a label #

new_label = {
    "name": "Birds",
    "description": "Adding birds to the mix",
    "color": "#00ff00",
    "shortcut": "b"
}

new_label = client.create_dataset_label(my_dataset["id"], new_dataset_version["id"], new_label)

new_label

Every dataset split has the following properties:

{
    'id': 'ea3be37d-ce48-44bc-4435-39d88a47a2d6',
    'created_at': '2021-11-02T14:24:06.187758716Z',
    'updated_at': '2021-11-02T14:24:06.187758716Z',
    'name': 'Birds',
    'description': 'Adding birds to the mix',
    'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
    'version_id': 'd774d5bd-40fd-4c5f-8043-f1a8ed88e0d2',
    'color': '',
    'index': 2
}

Properties in more detail:

Get a label #

my_label = client.get_dataset_label(my_dataset["id"], new_dataset_version["id"], new_label["id"])

Update a label #

my_label["color"] = "#00ff00"

my_label = client.update_dataset_label(my_dataset["id"], new_dataset_version["id"], my_label)

Delete a label #

client.delete_dataset_label(my_dataset["id"], new_dataset_version["id"], my_label)

Dataset label stats #

Get stats about items and annotations for every label in your dataset version

Get label stats #

Get label stats for a split in a dataset version

label_stats = client.get_label_stats(my_dataset["id"], new_dataset_version["id"], my_split["id"])

label_stats

label_stats is a list of stats for every label in the dataset version:

[

    {
      'id': '90d77e0c-9f22-452d-a884-d6b3d2fe651d',
      'created_at': '2023-01-17T21:47:30.167266+01:00',
      'updated_at': '2023-01-17T21:47:30.167266+01:00',
      'label_id': '20cdc039-5d41-4abe-86cb-ec8b734acbac',
      'split_id': 'e43e1df7-4de1-41b9-9d55-1fcf347070cb',
      'count': 0,
      'annotation_count': 0,
      'item_count': 0
      }
 ]
  

Detailed properties: see below.

Get stats for a specific label #

Get the stats for a specific label

label_stat = client.get_stats_for_label(label_stats, my_label["id"])

Properties in more detail:

Get stats for unlabelled #

Get the stats for unlabelled items.

unlabelled_stat = client.get_stats_for_unlabelled(label_stats)

Dataset Items #

A dataset version can contain many dataset items. Items are used to access and store the actual items in your dataset version such as images or text.

Get dataset items #

items = client.get_dataset_items(my_dataset["id"], new_dataset_version["id"])

# All params are optional, but here we combine them together for demo purposes. 
params = {
    "onlyUnlabelled": True,
    "pageSize": 25,
    "pageCount": 0,
    "labelId": new_label["id"],
    "splitId": my_split["id"]
}

client.get_dataset_items(my_dataset["id"], new_dataset_version["id"], params)

Create a dataset item #

item = {
    "name": "An optional name",
    "splits": [my_split]
}

item = client.create_dataset_item(my_dataset["id"], new_dataset_version["id"], item)

Every dataset item has the following properties:

{
     'id': 'e92dcc17-cbc2-4a1e-a332-4c62a3232ede',
     'created_at': '2021-11-02T16:07:15.88589873Z',
     'updated_at': '2021-11-02T16:07:15.88589873Z',
     'name': 'An optional name',
     'description': '',
     'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
     'text': '',
     'splits': [],
     'annotations': None,
     'extension': ''
 }

Properties in more detail:

Get a dataset item #

item = client.get_dataset_item(my_dataset["id"], new_dataset_version["id"], item["id"])

Update a dataset item #

item["description"] = "A better description"

client.update_dataset_item(my_dataset["id"], new_dataset_version["id"], item)

Delete a dataset item #

client.delete_dataset_item(my_dataset["id"], new_dataset_version["id"], item)

Upload a dataset item image #

client.upload_dataset_item_image(
    my_dataset["id"], 
    new_dataset_version["id"], 
    item["id"], 
    folder="directory/to/item", 
    filename="item_filename.jpg"
)

Download a dataset item image #

download_location = f"{item['id']}.{item['extension']}"

client.download_dataset_item_image(
    my_dataset["id"],
    new_dataset_version["id"],
    item["id"], 
    download_location, 
    thumbnail=False
)

Annotations #

Annotations link your dataset items to one or more labels in your dataset.

Create an annotation #

Create an annotation with label_id, split_id, and item_id.

annotation = {
    "label_id": my_label["id"],
    "split_id": my_split["id"],
    "item_id": item["id"],
    "coordinates": ""
}

annotation = client.annotate(my_dataset["id"], new_dataset_version["id"], annotation)

Every annotation has the following properties:

{
     'id': 'e92dcc17-cbc2-4a1e-a332-4c62a3232ede',
     'created_at': '2021-11-02T16:07:15.88589873Z',
     'updated_at': '2021-11-02T16:07:15.88589873Z',
     'label_id': 'ecd4f023-d13f-440a-8b9c-c341edd2c28b',
     'item_id': 'dab56b75-387c-4660-989f-2b3f953772c4',
     'split_id': 'b2ccc18d-4dcc-475a-b1a9-a281e574f695',
     'coordinates': '',
     'user_id': 'd7159432-f218-44ac-aebe-e5d661d62862',
     
 }

Properties in more detail:

Update an annotation #

Update a given annotation

annotation["coordinates"] = "14 20 34 48"

annotation = client.update_annotation(my_dataset["id"], new_dataset_version["id"], annotation)

Delete an annotation #

Delete a given annotation

client.delete_annotation(my_dataset["id"], new_dataset_version["id"], annotation)

Export Dataset Version #

client.download_dataset(
    my_dataset["id"],
    new_dataset_version["id"],
    split_id="",
    extract_to_dir="data",
    download_file="dataset.zip",
    remove_download_file=True,
    export_format=""
)

A note on the exported formats.

Image classification #

export_format: DATASET_FORMAT_FOLDERS

The .zip file contains a folder for every dataset split: “train”, “valid”, “test”.

Every dataset split folder contains a ’label-named’ folder for every label: “cats”, “dogs”.

Every label folder contains all the images of the dataset items for the given label in the given dataset split.

Dataset items are named by the “name” and “extension” property of the dataset item. If the “name” property is empty, the “id” is used to name the file.

Dataset items that have no label, will be added to the split folder to which they belong.

.
+-- train/
|  +-- cats/
|     +-- cat1.jpg
|     +-- cat12.jpeg
|  +-- dogs/
|     +-- dog2.jpg
|     +-- dog4.png
|  +-- cat17.jpeg
|  +-- dog15.jpg
+-- valid/
|  +-- cats/
|     +-- cat4.jpg
|     +-- cat8.jpg
|  +-- dogs/
|     +-- dog9.jpg
|     +-- dog14.png
+-- test/
|  +-- cats/
|     +-- cat90.jpg
|     +-- cat34.jpeg
|  +-- dogs/
|     +-- dog81.jpg
|     +-- dog98.png

Text classification #

export_format: DATASET_FORMAT_FOLDERS

The .zip file contains a folder for every dataset split: “train”, “test”, “unsup”.

Every dataset split folder contains a ’label-named’ folder for every label: “pos”, “neg”.

Every label folder contains all the images of the dataset items for the given label in the given dataset split.

Dataset items are named by the “name” and “extension” property of the dataset item. If the “name” property is empty, the “id” is used to name the file.

Dataset items that have no label, will be added to the split folder to which they belong.

.
+-- train/
|  +-- pos/
|     +-- 1.txt
|     +-- 3.txt
|  +-- neg/
|     +-- 2.txt
|     +-- 4.txt
+-- test/
|  +-- pos/
|     +-- 5.txt
|     +-- 7.txt
|  +-- neg/
|     +-- 6.txt
|     +-- 8.txt
+-- unsup/
|     +-- 13.txt
|     +-- 14.txt

Object detection #

export_format: DATASET_FORMAT_YOLO

Object detection datasets are exported in YOLO format.

For every dataset split a dataset_split_name.txt file gets created containing all the filenames for that dataset split.

Every dataset item will have an image and a txt file associated with it. The txt file contains a list of annotations in Yolo format: label_index relative_x relative_y relative_width relative_height.

The .names file contains the list of labels, where the index corresponds to the label_index in the annotation .txt files.

The config.json file contains a contains a json object with the color for every label.

.
+-- train.txt
+-- valid.txt
+-- test.txt
+-- 1.jpg
+-- 1.txt
+-- 3.jpg
+-- 3.txt
+-- ...
+-- dataset_version_id.names
+-- config.json

Tabular #

export_format: DATASET_FORMAT_CSV

Tabular datasets are exported in a .zip file that contains a dataset_version_id.csv file accompanied by a config.json, which provides more details on how the data should be interpreted.

.
+-- dataset_version_id.csv
+-- config.json

A little more details about the config.json file:

{
    "multi_label": false,
    "label_column": "labels",
    "split_column": "split",
    "label_separator": " ",
    "filename": "dataset_version_id.csv",
    "csv_separator": ","
}

Named entity recognition #

export_format: DATASET_FORMAT_SPACY_NER

For an named entity recognition dataset with splits:

• train
• valid
• test

the zip file should be structured in the following way:

.
+-- train.json
+-- valid.json
+-- test.json
+-- config.json

config.json #

The config.json file contains a list of dataset splits, as well as a color code for every label.

{
    "splits": [
        "train",
        "valid",
        "test"
    ],
    "colors": {
        "label_name": "#82ebfd",
        "label_name2": "#e95211"
    }
}

split_name.json #

For every dataset split, there is a ‘split_name’.json file with the following structure:

[{
    "id": "the_dataset_item_id",
    "name": "the_original_filename" ,
    "text": "The textual content of the file that has been annotated.",
    "annotations": [{
        "start": 4,
        "end": 11,
        "label": "label_name",
    },
     {
         ...
     }
    ]
},
{
    ...
}
]

Import Dataset Version #

Image classification #

format: DATASET_FORMAT_FOLDERS

For an image classification dataset with splits:

• train
• valid
• test

and labels:

• cats
• dogs

the zip file should be structured in the following way

.
+-- train/
|  +-- cats/
|     +-- cat1.jpg
|     +-- cat12.jpeg
|  +-- dogs/
|     +-- dog2.jpg
|     +-- dog4.png
|  +-- cat17.jpeg
|  +-- dog15.jpg
+-- valid/
|  +-- cats/
|     +-- cat4.jpg
|     +-- cat8.jpg
|  +-- dogs/
|     +-- dog9.jpg
|     +-- dog14.png
+-- test/
|  +-- cats/
|     +-- cat90.jpg
|     +-- cat34.jpeg
|  +-- dogs/
|     +-- dog81.jpg
|     +-- dog98.png

Text classification #

For an text classification dataset with splits:

• train
• valid
• unsup

and labels:

• pos
• neg

the zip file should be structured in the following way

.
+-- train/
|  +-- pos/
|     +-- 1.txt
|     +-- 3.txt
|  +-- neg/
|     +-- 2.txt
|     +-- 4.txt
+-- test/
|  +-- pos/
|     +-- 5.txt
|     +-- 7.txt
|  +-- neg/
|     +-- 6.txt
|     +-- 8.txt
+-- unsup/
|     +-- 13.txt
|     +-- 14.txt

Object detection #

format: DATASET_FORMAT_YOLO

Object detection datasets are imported in YOLO format.

For every dataset split a dataset_split_name.txt file gets created containing all the filenames for that dataset split.

Every dataset item will have an image and a txt file associated with it. The txt file contains a list of annotations in Yolo format: label_index relative_x relative_y relative_width relative_height.

The .names file contains the list of labels, where the index corresponds to the label_index in the annotation .txt files.

The config.json file contains a contains a json object with the color for every label.

.
+-- train.txt
+-- valid.txt
+-- test.txt
+-- 1.jpg
+-- 1.txt
+-- 3.jpg
+-- 3.txt
+-- ...
+-- dataset_version_id.names
+-- config.json

Tabular #

format: DATASET_FORMAT_CSV

Tabular datasets are imported from .csv files accompanied by a config.json file that provides more details on how the data should be interpreted.

.
+-- dataset.csv
+-- config.json

Config file #

A little more details about the config.json file:

{
    "multi_label": false,
    "label_column": "labels",
    "split_column": "split",
    "label_separator": " ",
    "filename": "dataset.csv",
    "csv_separator": ","
}

Named entity recognition #

format: DATASET_FORMAT_SPACY_NER

For an named entity recognition dataset with splits:

• train
• valid
• test

the zip file should be structured in the following way:

.
+-- train.json
+-- valid.json
+-- test.json
+-- config.json

config.json #

The config.json file contains a list of dataset splits, as well as a color code for every label.

{
    "splits": [
        "train",
        "valid",
        "test"
    ],
    "colors": {
        "label_name": "#82ebfd",
        "label_name2": "#e95211"
    }
}

split_name.json #

For every dataset split, there is a ‘split_name’.json file with the following structure:

[{
    "id": "the_dataset_item_id",
    "name": "the_original_filename" ,
    "text": "The textual content of the file that has been annotated.",
    "annotations": [{
        "start": 4,
        "end": 11,
        "label": "label_name",
    },
     {
         ...
     }
    ]
},
{
    ...
}
]

Jobs #

Get all jobs #

from seeme import JOB_STATUS_WAITING, JOB_STATUS_STARTED, JOB_STATUS_FINISHED, JOB_STATUS_ERROR, JOB_TYPE_TRAINING


jobs = client.get_jobs(
    application_id="", 
    states=[JOB_STATUS_WAITING, JOB_STATUS_STARTED, JOB_STATUS_FINISHED, JOB_STATUS_ERROR],
    job_types=[JOB_TYPE_TRAINING]
)

This method returns a list of job objects with the following properties:

{
    'id': '26cb7e7a-25a0-4faa-8e3a-d9ee2f0d0c71',
    'created_at': '2022-09-20T21:32:53.561561+02:00',
    'updated_at': '2022-09-21T00:48:10.614159+02:00',
    'name': 'Cats and dogs classification',
    'description': '',
    'job_type': 'training',
    'application_id': '10b957dd-5dfe-49b0-a500-61bb8f6564c6',
    'status': 'finished',
    'status_message': 'updating training request: finished',
    'user_id': '2b02eb44-8ad0-409c-9515-0405fb25d470',
    'cpu_start_time': '2022-09-20T19:37:42.461233',
    'cpu_end_time': '2022-09-20T22:48:10.610324',
    'gpu_start_time': '2022-09-20T19:38:19.492219',
    'gpu_end_time': '2022-09-20T22:47:22.688223',
    'agent_name': 'g7',
    'dataset_id': '8037b73a-5512-4a45-89e2-29761771fff6',
    'dataset_version_id': '1d3bf8d6-e39b-498e-9c08-680d2f8a3c47',
    'model_id': '010f68fe-87d6-418a-a622-d37923ec7164',
    'model_version_id': '82e31602-79ea-4cc2-971a-0baee4c0fbd7',
    'items': [{
        'id': '8493abc5-da89-4842-9406-c4914e2917c3',
        'created_at': '2022-09-20T21:32:53.562095+02:00',
        'updated_at': '2022-09-21T00:48:10.614535+02:00',
        'name': 'arch',
        'description': 'resnet50',
        'job_id': '26cb7e7a-25a0-4faa-8e3a-d9ee2f0d0c71',
        'value': 'resnet50',
        'default_value': 'resnet50',
        'value_type': 'text',
        'label': 'Architecture'
    }, {
        'id': 'aaae29eb-315e-407b-9f7b-d25eb11ce902',
        'created_at': '2022-09-20T21:32:53.562095+02:00',
        'updated_at': '2022-09-21T00:48:10.614535+02:00',
        'name': 'image_size',
        'description': '',
        'job_id': '26cb7e7a-25a0-4faa-8e3a-d9ee2f0d0c71',
        'value': '224',
        'default_value': '224',
        'value_type': 'number',
        'label': 'Image size'
    }, {
        'id': 'a582644b-31f7-421e-86f2-54dc6ddb9e0b',
        'created_at': '2022-09-20T21:32:53.562095+02:00',
        'updated_at': '2022-09-21T00:48:10.614535+02:00',
        'name': 'batch_size',
        'description': '',
        'job_id': '26cb7e7a-25a0-4faa-8e3a-d9ee2f0d0c71',
        'value': '32',
        'default_value': '32',
        'value_type': 'number',
        'label': 'Batch size'
    }, {
        'id': 'c1d6291a-1bd4-477d-a425-132cb2422f8f',
        'created_at': '2022-09-20T21:32:53.562095+02:00',
        'updated_at': '2022-09-21T00:48:10.614535+02:00',
        'name': 'nb_epochs',
        'description': '',
        'job_id': '26cb7e7a-25a0-4faa-8e3a-d9ee2f0d0c71',
        'value': '50',
        'default_value': '50',
        'value_type': 'number',
        'label': 'Number of epochs'
    }]

Job properties in more detail.

Job Item in more detail:

Create a job #

Create a training job:

from seeme import JOB_TYPE_TRAINING

my_job = {
    "name": "Train a new model for cats and dogs",
    "description": "",
    "job_type": JOB_TYPE_TRAINING, # "training"
    "application_id": "acf26cf4-e19f-425e-b5cb-031830a46df4", # See Applications to get the correct application_id for your job
    "dataset_id": "8037b73a-5512-4a45-89e2-29761771fff6", # Update to your dataset_id
    "dataset_version_id": "1d3bf8d6-e39b-498e-9c08-680d2f8a3c47", # Update to your dataset_version_id
    "items": [
        {
            "name": "image_size",
            "value": "224",
            "value_type": "number",
            "label": "Image Size"
        },
        {
            "name": "arch",
            "value": "resnet50",
            "value_type": "text",
            "label": "Architecture"
        },
        {
            "name": "batch_size",
            "value": "50",
            "value_type": "number",
            "label": "Batch size"
        }
    ]
}

my_job = client.create_job(my_job)

Supported job items per applications #

Every job item can be customised depending on the AI application you are using. Below we list all the possibilties per AI application.

Image classification #

Architecture

job_item = {
    "name": "arch",
    "value": "resnet50",
    "value_type": "text",
    "label": "Architecture"
}

Image size:

job_item = {
    "name": "image_size",
    "value": "224",
    "value_type": "number",
    "label": "Image Size"
}

Image resize:

job_item = {
    "name": "image_resize",
    "value": "460",
    "value_type": "number",
    "label": "Image Resize"
}

Batch size:

job_item = {
    "name": "batch_size",
    "value": "32",
    "value_type": "number",
    "label": "Batch Size"
}

Number of epochs:

job_item = {
    "name": "nb_epochs",
    "value": "50",
    "value_type": "number",
    "label": "Number of epochs"
}

Mix up %:

job_item = {
    "name": "mixup",
    "value": "0",
    "value_type": "number",
    "label": "Mix up %"
}

Seed:

job_item = {
    "name": "seed",
    "value": "12",
    "value_type": "number",
    "label": "Seed"
}

Object detection #

Architecture:

job_item = {
    "name": "arch",
    "value": "yolov4-tiny",
    "value_type": "number",
    "label": "Architecture"
}

Image size:

job_item = {
    "name": "image_size",
    "value": "416",
    "value_type": "number",
    "label": "Image Size"
}

Batch size:

job_item = {
    "name": "batch_size",
    "value": "64",
    "value_type": "number",
    "label": "Batch Size"
}

Subdivisions:

job_item = {
    "name": "subdivisions",
    "value": "8",
    "value_type": "number",
    "label": "Subdivisions"
}

Named entity recognition (NER) #

Language:

job_item = {
    "name": "language",
    "value": "en",
    "value_type": "text",
    "label": "Language"
}

Optimize for:

job_item = {
    "name": "optimize",
    "value": "accuracy",
    "value_type": "multi",
    "label": "Optimize for"
}

Tabular #

Architecture:

job_item = {
    "name": "arch",
    "value": "[200 - 100]",
    "value_type": "text",
    "label": "Architecture"
}

Batch size:

job_item = {
    "name": "batch_size",
    "value": "32",
    "value_type": "number",
    "label": "Batch Size"
}

Number of epochs:

job_item = {
    "name": "nb_epochs",
    "value": "50",
    "value_type": "number",
    "label": "Number of epochs"
}

Get a job #

my_job = client.get_job(my_job["id"])

Update a job #

my_job["description"] = "Update any property"

my_job = client.update_job(my_job)

Delete a job #

client.delete_job(my_job["id"])

Applications #

SeeMe.ai supports multiple types of AI models, frameworks, and framework versions. To access, manage, and describe these, we use applications:

Get all supported applications #

Print a list of the applications in your SeeMe.ai client:

client.applications

Every application has the following properties:

{
    'id': '878aea66-16b7-4f10-9d82-a2a92a35728a',
    'created_at': '2022-09-19T17:57:14.323965Z',
    'updated_at': '2021-09-19T17:57:14.323965Z',
    'base_framework': 'pytorch',
    'base_framework_version': '1.12.1',
    'framework': 'fastai',
    'framework_version': '2.7.9',
    'application': 'image_classification',
    'inference_host': 'image-pt-1-12-1-fa-2-7-9',
    'can_convert_to_onnx': True,
    'can_convert_to_coreml': True,
    'can_convert_to_tensorflow': True,
    'can_convert_to_tflite': True,
    'has_labels_file': True,
    'inference_extensions': 'pkl'
}

Properties in more detail.

You can update the local list of applications by:

client.applications = client.get_applications()

Get the application id #

Before you can upload and use your model to make predictions, you need to add an application_id:

from torch import __version__ as torch_version
from fastai import __version__ as fastai_version

# Get the application_id for your framework (version).
application_id = client.get_application_id(
    base_framework="pytorch",
    framework="fastai",
    base_framework_version=torch_version,
    framework_version=fastai_version,
    application="image_classification"
)

If your combination is not supported, you will get a NotImplementedError.

Feedback #

For questions, feedback, corrections: contact support@seeme.ai.