Processings

1. What is a Processing?

A Processing is a piece of code (like a Python script) executed on Picsellia infrastructure that can interact with any object related to your Organization (Datalake, DatasetVersion, ModelVersion..).

This page details how to use a Processing on a DatasetVersion.

The following pages are dedicated to the use of Datalake Processing and ModelVersion Processing.

To explain this, let's start with a use case:

Let's say you want to perform data augmentation on a Picsellia DatasetVersion.

Normally, the steps to achieve this would be:

• Downloading your images locally
• Running a script with some data-augmentation techniques (like rotating the image for example) on all of your images
• Creating a new DatasetVersion you are using
• Uploading the augmented images to this new DatasetVersion

We know it can feel a little bit overwhelming. Although running a script can be considered an automatic task, this process is fully manual. In addition, you must be using a computer that is able to run the code (it has to be in the correct environment, etc...)

This is why we came up with Processing, to let you automate this process and launch it whenever you want, on the data you want, directly from the platform!

So let's see how to use the most common Processing, the pre-annotation of a DatasetVersion.

A Processing can be run on a DatasetVersion, so you can perform tasks like:

• Pre-annotation with a ModelVersion
• Data Augmentation
• Smart Version Creations
• Or anything you can think of regarding your data!

2. Access the Processing list

First of all, you can at any moment reach the list of available Processing by clicking on Processings on the Navigation bar as shown below:

This page provides access to all the Processing available for the current Organization.

They are sorted by type of object they can be used on, meaning:

• Datalake
• DatasetVersion
• ModelVersion

For each type of Processing, you will have access to all the Processing created by the Picsellia DataScience team (called Public Processings) alongside the ones you created (called Private Processings).

On this view, for each Processing is displayed its Name, Description, Task, and potential constraints.

It is also from this view that you can create or update any Private Processing. More details on this topic are available here.

3. Use a Processing on a DatasetVersion

Now that we can easily list the available Processing, it is high time to use them. In our case, we will use one on a DatasetVersion.

Let's see one of the most useful examples: Pre-annotation with a ModelVersion from your Registry.

First of all, let's access the DatasetVersion on which the Processing should be applied to.

Then, select all the Asset and click on process as shown below:

A modal will then open, letting you choose among the Public and Private Processing, the one to be executed on the current DatasetVersion.

Depending on the Processing configuration, you might be requested to provide some inputs or parameters to make sure the Processing can be executed as expected. These inputs can be parameters, the name of the new DatasetVersion or select a ModelVersion for instance.

In the frame of our Pre-Annotation use case, a ModelVersion is required as Input, so the Model Registry will open, allowing you to select the ModelVersion to be used.

Please note that an Input to a Processing can be either a Picsellia object (DatasetVersion, ModelVersion, or Datalake) and in that case a selector will open allowing you to select the required object available in the current Organization, a Text or a Number and in that case a field will be displayed to prompt its value.

Then a Processing also has a list of parameters that already have default values, and it aims to allow the user to precisely fine-tune the behavior of the script behind the Processing. Usually, the default values are defined to make it work in a standard configuration.

Typically in our use case, it will be the confidence threshold that allows the user to define above which confidence score a Shape predicted by the selected ModelVersion must be kept.

Please note that a DatasetVersion Processing can also embed constraints on the Version Type. It means that, for example, a Processing can only be executed on a Segmentation DatasetVersion; in case it is launched on a non-supported Version Type, the following error will occur:

Once everything is properly setup you can launch the Processing execution by clicking on Launch, the associated Docker image will then be executed on the default infrastructure, please note that if you have several compute infrastructures integrated with your Picsellia Organization, you will be able to select the one to run the Processing on, as shown below:

To integrate a new compute infrastructure you need to define a Compute Connector, you can rely on this documentation page.

To create your own Processing on the Picsellia platform, you can rely on the documentation available here.

4. Track the Processing progress

When you launch a Processing, it creates a Job running in the background. You can access the status and much more information about it in the Jobs tab.

On this page, you can see the history of all the Jobs that ran or are currently running, they can be either Processing Jobs, Training Jobs, or Internal Jobs. In our case, you can filter on Processing Jobs.

If you just launched a Processing, you should see it at the top of the list. Let's inspect our freshly launched pre-annotation Job.

When you launch a Processing, there will be a short moment when the status will be pending. Once your Job has been scheduled (and you start being billed), the status will change to running and you will see some logs being displayed in real-time (those come from the stdout of the server it runs on).

This way, you can really track the progress and the status of your Job and check that everything is going well. In addition, it is a way to keep track of any performed action on a DatasetVersion, such as what Processing has been executed, when, and by whom.

Once your Job is over, you will have access to the full history of logs, and the total running time, and the status will switch to succeeded (or failed, if there were issues at runtime).

Your Job will fail sometimes, but you'll be able to find the issue thanks to the stack trace in the Job logs:

Once you have detected the issue, you have fixed it, and you have updated your Processing's Docker Image, you can click on the Re-run Job button. This will create and launch a second run with the same configuration (Inputs and Parameters).

Now that our Job has finished, let's have a look at our DatasetVersion! It should be fully annotated with the defined Label.

Our DatasetVersion has been nicely pre-annotated by our ModelVersion with barely any effort. That's the power of DatasetVersion Processings on Picsellia.