sa.engine is a software based platform and toolbox with three essential strengths:
Altogether, this is what makes sa.engine uniquely powerful as a tool for providing smartness in edge devices of any kind and of any size, allowing you to communicate intelligently and interactively with your products or assets, in real time.
Looking under the hood, what makes this possible is a highly advanced, yet streamlined and robust architecture, including an object-oriented main-memory database engine, a computational engine, a data stream processor, and an inference engine. All in a footprint ranging from 100 kB to 5.2 MB, making it possible to run sa.engine in different configurations directly on devices and microcontrollers having sufficient memory:
Query and analysis language
Adding to this is a high-level query and analysis language called OSQL (Object Stream Query Language) and a Visual Analyzer Development Environment, allowing model-development directly on edge devices, using two intuitive interfaces:
With OSQL, computations and filters over real-time streaming data are defined as mathematical formulas and expressions, called stream models. OSQL models are specified on a very high level without the need for deep programming knowledge; they specify what to do rather than how to execute the models, meaning that you don’t need to worry about details on how to efficiently implement programs that integrate large numbers of edge devices.
Queries and models may continuously make computations and filtering over measurements in a data stream, called continuous queries, CQs. The result of a CQ is a real-time object stream of processed and filtered measurements, for example a CQ returning a stream of the position vectors of a device measured every second whenever it is close to a given geo-position.
In-memory database and security
Both stream models and user data are stored in sa.engine’s very fast object-oriented in-memory database. These databases are important for data stream processing, which usually involves matching fast flowing stream objects against data in a database in real time.
Having user data and models stored locally in the database is also important from a security perspective, since it allows for role-based authentication, as opposed to authentication methods that either give full access or no access at all to the system, which is common in most edge devices.
Building on the internal resources in sa.engine, the system also allows for strong additional security functions with AI based analytics, automatically detecting false data-injection attacks and cyber anomalies in industrial networks.
Object streams from several edge devices can be combined and are then called fusion queries. An example is a CQ observing when several edge devices in an area detect strong vibrations at the same time, which could indicate e.g. an earthquake.
In order to combine heterogeneous data streams from different devices, incoming object streams are mapped to a universal model called an ontology, running on a name server where sa.engine is configured to monitor multiple edge devices.
Predefined library and foreign functions
The system includes a library of over 1,000 predefined OSQL-functions for mathematical and statistical computations, object stream filtering and transformation, signal processing, model and data management, data mining, and much more.
Existing algorithms and libraries implemented in a regular programming language, such as C or Java, can be plugged into the system as foreign functions implementing OSQL functions using language specific APIs. There are currently foreign function APIs available for C, C++, Lisp, Java, and Python.
Common machine learning algorithms such as DBSCAN, DenStream, k-NN, and k-means are available as predefined OSQL functions, and the user can easily extend the machine learning library with other algorithms defined in OSQL or as foreign functions.
Machine learning requires pre-processing of sensor data before applying the learned inference algorithm, followed by post-processing of the inferred knowledge. With sa.engine, both pre- and post-processing are easily expressed using the powerful object stream filtering, transformation, and math/stat analytics capabilities of OSQL.
The system includes a deep learning subsystem, SANN, where neural network models defined by Tensorflow/Tensorboard can be automatically translated into an internal binary SANN representation and pushed out to the edge databases. Once stored in an edge database the SANN inference engine can analyze local sensor readings to detect anomalies.
SANN furthermore allows to continue training and even building neural networks on edge devices. Thus, centrally trained models can be further retrained and modified on edge devices to adapt their behavior to their environment.
In particular, sa.engine provides a powerful tool for developing TinyML AI models by its ability to not only deploy and execute AI models on tiny devices, but also to interactively develop and adapt them there.
OS and software independence
The sa.engine is built for being embedded into, or integrated with other software infrastructures such as Android, MCU:s, AWS, Azure, HMS tag engine, Kafka, Event Hub, Tensorflow, Matlab, Relational Databases (such as Mysql), and MongoDB to name a few—using the open SDK:s for C, C++, Lisp, Java, Python, PHP, Android, Node.js, and JDBC.
However, by being complete and stand-alone with a highly generalized architecture it can also function in primitive software and hardware environments, or even work entirely on its own. This is made possible by sa.engine being completely OS agnostic and independent of other software, allowing you to easily deploy and embed it into your current software environment.