Overview of Aito

Aito is the AI Database for Developers that lets you query predictions like you query data. Instead of building complex machine learning pipelines, you can add intelligent features to your applications using familiar database-like queries.

When you upload data to Aito, it automatically learns patterns and relationships without requiring model training or feature engineering. At query time, you can make predictions using simple API calls. For example, you could predict a product's category based on its description and price.

Predict the category of a product

This approach scales to complex, real-world datasets. Upload your historical data once, and you can immediately start making intelligent predictions without managing models or complex ML infrastructure.

Tables and columns

Aito models your data in a similar way as traditional relational databases: as a collection of tables with a pre-defined data structure. The whole database is described with a schema object, which looks like this:

{
  "schema": {
    "users": {
      "type": "table",
      "columns": {
        "id": { "type": "String" },
        "name": { "type": "String" },
        "age": { "type": "Int", "nullable": true }
      }
    },

    "messages": {
      "type": "table",
      "columns": {
        "id": { "type": "String" },
        "user": { "link": "users.id", "type": "String" },
        "text": { "type": "Text", "analyzer": "English" }
      }
    }
  }
}

Schema supports basic data types, nullable fields and one-way links. The type information allows Aito to better analyze the features of the data and also links between tables are used as information for machine learning functions. Uploaded data is validated against the given schema.

How does Aito work?

At the heart, Aito is a statistical machine that analyzes the inserted data into features with statistical properties. Aito uses these statistical properties to perform machine learning operations.

How the featurisation is done, depends on the field type. For example the Text type supports an "analyzer" option which allows you to control how a text field is splitted into features. Some queries, for example Relate, return the features instead of the actual values of the field.

In addition to splitting into features, Aito calculates statistical properties for them. You can access some of the statistical properties through Relate API. The returned properties include the frequency of the feature, the frequency given some condition, relationships with other features, etc.

You can read more about Text field analyzers from our API docs.

How is Aito different?

Aito is a different type of approach to making your software smart. In many cases, that's the business need behind machine learning technology. The obvious benefit of Aito is convenience – deployments, hosting, scaling, monitoring, and security are taken care for you. Other distinctive features of Aito are automatic feature selection and query-time modeling.

The easiest way to understand is by comparing the workflow of a "traditional" machine learning project to how it would be done with Aito. As an example, let's consider a few smart features in modern email services. To automatically detect spam emails, traditionally you'd go through these basic steps to integrate the machine learning functionality to your email service:

Now you can classify email as spam or not spam with the deployed model. These steps would be then iterated again when the model needs to be retrained with new data.

After this you implement a new smart feature which suggests who you should most likely add to the CC field of the email. You have gained experience of the dataset to work more efficiently, but you still need to do the same steps again:

.. and this continues for each different machine learning problem. The Aito workflow on the other hand is more similar to a workflow of using a database:

After the data has been inserted into Aito, you can solve a dynamic set of problems which are solvable in the limits of the query language. In the email service example, we would now be able to:

• Classify emails as spam or not spam
• Predict the most likely person who to add into the CC field
• Search emails which match to a given phrase
• Match a relevant ad based on the email body text
• Explain what features of an email are most typical for a spam email
• .. and much more! Check out the API docs for examples.

The teaching of Aito happens by inserting new data points via the API.