Robovision SDK

Focus on what matters

Build your own IP library and manage vision AI pipelines with the ease of a notebook. Robovision SDK, with the power of production deployment, provides all the development tools you need to handle the diverse and dynamic landscape of AI. Streamline model creation, deployment and management activities to deliver enterprise-grade AI.

  • Easily push codes to the Robovision Platform
  • Reuse codes and existing building blocks
  • Avoid code duplication and keep it clean
  • Simplify debugging and accelerate releases
  • Standardise algorithms

One place to access all your ML assets

Robovision SDK standardises the implementation of algorithms: debug and test them at runtime to automatically parallelise the algorithms, allowing for higher throughputs. Then, easily extend the capabilities of newly developed algorithms with the Robovision Platform to create, deploy and manage AI models. Developers can work in one single environment with access to all ML assets.

1

Create a new algorithm with Robovision SDK

Create a new algorithm with the Robovision SDK using your programming language of choice.
2

Develop a model with Robovision Platform

Once tested and validated, push it to the Robovision Platform to label data, train the model and deploy it.
3

Explore data with Jupyter Notebook

In the Jupyter notebook, explore data to uncover its patterns and build efficient predictive models.

More than a powerful tool

When every member writes code on his or her own, it is time consuming and inefficient to unravel them. Robovision SDK was built to break down team silos. It enables members to work together on shared models and datasets. Version history helps everyone keep track of changes and evaluate previous work. No matter the size of a project or how complex it is, managing AI efforts should be a priority for companies.

  • Boost model creation value by streamlining model development and maintenance work
  • Add custom algorithms to the Robovision Platform and keep intellectual property (IP) inhouse
  • Facilitate the creation of new solutions and quickly roll them out at scale

Why choose Robovision SDK?

Robovision SDK helps developers increase productivity, while offering them development freedom, data ownership, high performance and clean APIs. This simplifies debugging for developers and accelerates releases for companies. 

Productivity

Robovision SDK keeps unnecessary complexities away as developers can work in one single environment. With existing building blocks, they can reuse them and achieve efficiencies. Developers now can focus on improving their work rather than rewriting codes and making different frameworks interact with each other.

Freedom

Robovision SDK keeps unnecessary complexities away as developers can work in one single environment. With existing building blocks, they can reuse them and achieve efficiencies. Developers now can focus on improving their work rather than rewriting codes and making different frameworks interact with each other.

Data ownership

Data in every project is fully described, such as which type of images uploaded or how a data sample and annotation should look like. This makes sure data is correct before starting the training. With immutable data sets, repeat the same training on the same data at a later time. 

High performance & Clean API design

Keep algorithms in a single docker container. This means multiple processes and cells will communicate with each other. 

Swagger is integrated with Robovision SDK to help developers effectively create documentation of APIs. Moreover, with auto-generated clients, the APIs can easily interface with the Robovision Platform.

Book a demo

Put an end to ML chaos and start scaling

Robovision SDK is a powerful ML toolset of building blocks that will drive value for your AI initiatives. Get pre-set resources like runtimes and annotated datasets to develop, deploy and manage AI projects everywhere. 

A cell is the smallest building block of Robovision SDK which can be seen as a function with an input and an output. Any (machine learning) algorithm can be wrapped in a cell by implementing the required methods. We offer various standard cells as illustrated above. 

Complex data flows can be set up by connecting multiple cells together in a pipeline. The output of one cell can only be connected to the input of another cell if the IO types match. This also means that developers can make use of other existing cells without having to know the details of the implementation. Once constructed, the pipeline requires a set of inputs which is referred to as the pipeline source that produces some outputs, based on the internal cell connections called the pipeline sink. 

When creating a pipeline, a set of blocks and algorithms is defined. Algorithms still have to be created for a custom application by training a model. An algorithm is just a structure but when being fed with data, it becomes an application. Once a pipeline is built and trained, it can be loaded back into the Robovision Platform and made available to users in the field.

Reuse custom codes! A pipeline’s source and sink can be driven by a pipeline driver which feeds input data to the source and processes the results from the sink automatically. This makes it possible to ‘expose’ and then use the result anywhere. It can also be done at runtime so that the implementation of the pipeline does not need to be adjusted to support another driver, allowing for the same code to be reused in different circumstances and for different kinds of clients or use cases. 

An example of a pipeline driver is an HTTP API server, which converts HTTP prediction requests to pipeline inputs and returns the pipeline outputs as HTTP responses. Another example is to link a camera stream to the pipeline and write the processed results to a database.

Robovision SDK provides a programming environment with various runtimes (engines that pass along data being created). A runtime is responsible for executing pipelines and pipeline drivers.

The power of this is that while keeping the same cells/pipeline implementation, it is possible to use a different runtime with different priorities based on the use case. The functionality of a runtime can also be expanded with plugins; for example, for monitoring the pipelines.

Examples:

  • Ray Runtime

Ray is a distributed computing platform that allows running processes in parallel. It enables scaling of duplicated cells so data will be distributed between multiple instances resulting in a significant boost in throughput.

  • Debug Runtime

To run cells sequentially, it is easier to debug and more suitable for basic pipelines that have lower response restrictions.

Standardise types & formats

For cells to understand the output of each other, it is necessary to standardise the types and serialisation formats in the Robovision Platform. Therefore, the Robovision Platform’s types support a whole range of common types, but can be extended with custom types that are provided. This helps solve the following problem:

Machine learning frameworks often have different APIs, which make them not easy to integrate directly with other platforms or tools. Therefore, Robovision SDK provides an API to wrap algorithms into standardised cells which speed up developers’ work and enable reusability for future ideas.

Unleash the power of ML OPS

Reproducibility aka version everything

Datasets, models, parameters, notebooks, and environments

Continuous delivery

Integration of continuous integration and delivery (CI/CD) tools

Accountability

Traceability of data & models

Deployment

Deployment of models via Docker to Kubernetes

Collaboration

Share and collaborate on all components

Monitoring

Statistical model monitoring via the Prometheus time-series database, and visualization with Grafana

On-premises

In the cloud

At the edge

Build your own IP library

Start with Robovision