Our cases
We’ve built solid experience working on a wide range of tasks that involved machine learning, data storage migration and optimization, blockchain analytics, configuring inference for unconventional platforms, building transactional storage systems and layers, compiling cryptography into .wasm and integrating ML tools into web applications.
BigDataDuck
Video analytics for hospitals and healthcare
Intelligent video analytics enables hospital security systems to automatically monitor the premises and trigger real-time responses to emergencies and disturbances. A neural-network based video monitoring system can instantly detect, analyze and identify whether a patient needs attention or there is an unauthorized person on the premises, and notify a nurse or hospital security respectively.
Task: Build an intelligent video analytics system to analyze security camera footage in real time for hospitals and healthcare facilities.
Subtask: Reduce the workload on servers that receive events transmitted from cameras for analysis.
Solution: Enable continuous analysis of events and video-stream filtering at camera level using neural networks.
Our aim was to establish continuous analysis of images and events captured by CCTV cameras to filter out non-events, efficiently analyze notable events and respond to emergencies in real time. This required using ML tools to train neural networks to recognize images and check them against a database, detect movement and direction, and analyze retrieved information.
Our team delivered every component of this project except for building the neural networks.
Depending on the technical profile of the cameras in place, we would use one of the following options for filtering streams of events passed between the cameras and the analytics server:
a) Each camera is directly connected to the server, streaming unfiltered video data.
b) Cameras are divided into clusters and each cluster is connected to a local mediation server hosting a neural network that analyzes data streamed from several cameras, filtering out non-events before passing on data to the central analytics server. The mediation server transmits video data streams in full, but it filters the stream of events that the central server will have to process.
c) Each camera is equipped with its own, custom-coded neural network, which analyzes the incoming video stream following dynamically generated rules, filters out non-events and transmits a reduced data stream to the server.
We used machine learning algorithms to set data filtering tasks for neural networks, built an ML pipeline for training and a separate one for retraining neural networks. We also designed a custom inference engine for this project, capable of running on small processing units such as video camera processors.
A number of medical facilities in different countries are currently using intelligent video analysis systems we helped build.
Tech stack employed: Python, Go, C++, CUDA, Tensorflow, PyTorch, TensorRT
Task: Build an intelligent video analytics system to analyze security camera footage in real time for hospitals and healthcare facilities.
Subtask: Reduce the workload on servers that receive events transmitted from cameras for analysis.
Solution: Enable continuous analysis of events and video-stream filtering at camera level using neural networks.
Our aim was to establish continuous analysis of images and events captured by CCTV cameras to filter out non-events, efficiently analyze notable events and respond to emergencies in real time. This required using ML tools to train neural networks to recognize images and check them against a database, detect movement and direction, and analyze retrieved information.
Our team delivered every component of this project except for building the neural networks.
Depending on the technical profile of the cameras in place, we would use one of the following options for filtering streams of events passed between the cameras and the analytics server:
a) Each camera is directly connected to the server, streaming unfiltered video data.
b) Cameras are divided into clusters and each cluster is connected to a local mediation server hosting a neural network that analyzes data streamed from several cameras, filtering out non-events before passing on data to the central analytics server. The mediation server transmits video data streams in full, but it filters the stream of events that the central server will have to process.
c) Each camera is equipped with its own, custom-coded neural network, which analyzes the incoming video stream following dynamically generated rules, filters out non-events and transmits a reduced data stream to the server.
We used machine learning algorithms to set data filtering tasks for neural networks, built an ML pipeline for training and a separate one for retraining neural networks. We also designed a custom inference engine for this project, capable of running on small processing units such as video camera processors.
A number of medical facilities in different countries are currently using intelligent video analysis systems we helped build.
Tech stack employed: Python, Go, C++, CUDA, Tensorflow, PyTorch, TensorRT
Case 1
ML
low level
Machine learning for medical diagnostics
Task: Build a neural network-aided image analysis system for analyzing medical diagnostic images (e.g. X-ray and photofluorography images, sonograms, MRI and CT scans, etc.)
Subtask: For cost-efficiency purposes, design the system to run inference on CPU instead of GPU.
In this case we took part in a collaborative project to design a process where diagnostic images would be passed via a Kafka broker to a system of neural networks trained for image recognition and retrieval, and for further interpretation and analysis of results based on the matches. Analysis results would be passed back to Kafka.
Our team developed all of the software solutions for this project except for the ML models, and succeeded in configuring inference to run efficiently on general-purpose CPUs, making the process more cost-efficient.
Tech stack employed: Python, Go, C++, CUDA, PyTorch, Tensorflow, TensorRT
Subtask: For cost-efficiency purposes, design the system to run inference on CPU instead of GPU.
In this case we took part in a collaborative project to design a process where diagnostic images would be passed via a Kafka broker to a system of neural networks trained for image recognition and retrieval, and for further interpretation and analysis of results based on the matches. Analysis results would be passed back to Kafka.
Our team developed all of the software solutions for this project except for the ML models, and succeeded in configuring inference to run efficiently on general-purpose CPUs, making the process more cost-efficient.
Tech stack employed: Python, Go, C++, CUDA, PyTorch, Tensorflow, TensorRT
Case 2
ML
data engineering
AI-powered image search / Neural image retrieval
Task: Build a superfast neural search system for image retrieval (e.g. trademark image retrieval)
Subtask: Enable the retraining of neural networks when converting them from float32 to int8 or int16
Legacy tech stack: CUDA, C++, Python, gRPC
Solution: We built an ML-pipeline for training neural networks, which continuously analyses neural network structure to identify and remove redundant connections, thereby simplifying the structure. This enables neural networks to run even on the most basic hardware.
We developed a custom-built in-memory DBMS for our image retrieval system, enabling it to process upwards of 1 mln matches per 100 ms. It is employed whenever a strict match is required, while a FAISS library is used in other cases.
To support the conversion from float32 to int8 and int16 we built a separate pipeline for fast retraining of neural networks following relevant layer replacement.
Tech stack employed: CUDA, C++, Python, gRPC, PyTorch, Tensorflow, TensorRT
Inference: OpenCV, OpenVINO
Processor core: ARM Cortex-A8
Subtask: Enable the retraining of neural networks when converting them from float32 to int8 or int16
Legacy tech stack: CUDA, C++, Python, gRPC
Solution: We built an ML-pipeline for training neural networks, which continuously analyses neural network structure to identify and remove redundant connections, thereby simplifying the structure. This enables neural networks to run even on the most basic hardware.
We developed a custom-built in-memory DBMS for our image retrieval system, enabling it to process upwards of 1 mln matches per 100 ms. It is employed whenever a strict match is required, while a FAISS library is used in other cases.
To support the conversion from float32 to int8 and int16 we built a separate pipeline for fast retraining of neural networks following relevant layer replacement.
Tech stack employed: CUDA, C++, Python, gRPC, PyTorch, Tensorflow, TensorRT
Inference: OpenCV, OpenVINO
Processor core: ARM Cortex-A8
Case 3
ML
high performance
data engineering
Video Analytics
Task: Enable continuous analysis of events and video-stream filtering at camera level using neural networks in order to reduce the workload on servers that receive video data transmitted from CCTV cameras for analysis.
Solution: Equip each camera with its own, custom-coded neural network to analyze incoming video data following dynamically generated rules, filter out non-events and transmit a reduced data stream to the analytics server.
We used machine learning algorithms to compose data filtering tasks for neural networks, and built an ML pipeline for training neural networks. We also designed a custom inference engine for this project, capable of running
on small processing units such as video camera processors.
Tech stack employed: Python, Go, C++, CUDA, Tensorflow, PyTorch, TensorRT
Solution: Equip each camera with its own, custom-coded neural network to analyze incoming video data following dynamically generated rules, filter out non-events and transmit a reduced data stream to the analytics server.
We used machine learning algorithms to compose data filtering tasks for neural networks, and built an ML pipeline for training neural networks. We also designed a custom inference engine for this project, capable of running
on small processing units such as video camera processors.
Tech stack employed: Python, Go, C++, CUDA, Tensorflow, PyTorch, TensorRT
Case 4
ML
high performance
low level
Integrating ML Models in a Web Application
Task: Build a superfast video analytics system for a video streaming service with a tiered subscription model to track content viewed by the subscriber and identify switches between content categories in order to enable instant billing.
Solution: Integrate machine learning tools in a browser application.
Our job was to enable real-time neural image analysis of streamed video content coupled with real-time analysis of user behavior. We did this by integrating a Wasm Javascript module in the web application.
First, we had to convert a multitude of neural networks built for this task to int8, then convert the ML models to C++ code and compile them into a WebAssembly module. We used a few open-source solutions to compensate for slower application performance caused by using the TensorFlow.js library.
Integrating the C++ processing code in the web application enabled us to reduce the system load when converting the video stream from the browser to the Wasm module, and bring down data processing overhead costs from X5 to X1.5-2, as well as optimize image processing.
We built a system capable of analyzing the content of a video stream within five frames in real time, and recognizing not only faces but also objects in the picture.
Solution: Integrate machine learning tools in a browser application.
Our job was to enable real-time neural image analysis of streamed video content coupled with real-time analysis of user behavior. We did this by integrating a Wasm Javascript module in the web application.
First, we had to convert a multitude of neural networks built for this task to int8, then convert the ML models to C++ code and compile them into a WebAssembly module. We used a few open-source solutions to compensate for slower application performance caused by using the TensorFlow.js library.
Integrating the C++ processing code in the web application enabled us to reduce the system load when converting the video stream from the browser to the Wasm module, and bring down data processing overhead costs from X5 to X1.5-2, as well as optimize image processing.
We built a system capable of analyzing the content of a video stream within five frames in real time, and recognizing not only faces but also objects in the picture.
Case 5
ML
frontend
performance
Blockchain Analytics
Task: Build a process for blockchain analytics (Bitcoin, Ethereum) for AML monitoring purposes.
We identified three types of tasks for blockchain analytics with regard to this project:
1. Checking the last few transactions from the crypto wallet (or wallets) of a known customer,
2. Doing a careful check of all accounts and transactions of a new private customer,
3. Running a deep search and check of all accounts and transactions of a corporate customer or a private customer owning multiple crypto wallets.
The type of task instructs the depth of the search and the type of DBMS used for processing the request. We would use ArangoDB for regular requests, ClickHouse for urgent requests, and our own custom-built graph DBMS for running superfast checks by processing a specific set of requests. (Our homemade DBMS is based on a concurrent Dijkstra's algorithm analyzing segmented node groups based on segmentation attributes set by the client at their own discretion.)
We continue to maintain and evolve this process for our client as part of ongoing, long-term technical support, gradually adding on new features.
Tech stack employed: Python, C++
We identified three types of tasks for blockchain analytics with regard to this project:
1. Checking the last few transactions from the crypto wallet (or wallets) of a known customer,
2. Doing a careful check of all accounts and transactions of a new private customer,
3. Running a deep search and check of all accounts and transactions of a corporate customer or a private customer owning multiple crypto wallets.
The type of task instructs the depth of the search and the type of DBMS used for processing the request. We would use ArangoDB for regular requests, ClickHouse for urgent requests, and our own custom-built graph DBMS for running superfast checks by processing a specific set of requests. (Our homemade DBMS is based on a concurrent Dijkstra's algorithm analyzing segmented node groups based on segmentation attributes set by the client at their own discretion.)
We continue to maintain and evolve this process for our client as part of ongoing, long-term technical support, gradually adding on new features.
Tech stack employed: Python, C++
Case 6
Blockchain
backend
data engineering
Fintech: Upgrading Data Storage
Task: Upgrade a banking institution’s storage system used for storing, monitoring and managing customer assets.
Subtask 1: The upgrade should help reduce the cost of transactions handled by the system by $0.04 on average.
Subtask 2: Existing microservice architecture integrated with the legacy system should be preserved while legacy components should be replaced with new solutions.
Subtask 3: Bank staff should be able to operate the system without having profound IT skills.
Legacy tech stack: Perl, ANSI C99, COBOL (a rare version).
The legacy data storage and asset management system had an intricate and mottled structure where different components had been built at different times and with different tech stacks. While upgrading it, we were to preserve a large number of interfaces that had been built and integrated with the system over the past 20 years.
We advised our client to phase out the part of their system that was responsible for data storage and inventory. We would replace it with our own custom-built, turnkey solution, which was a multi-node data processing system with a pre-selected set of consistent operations grouped into families of mutually disjoint sets. It can analyze sequences of events, user groups or separate transactions.
We have been working on this project since 2016. Analyzing the legacy system alone took almost five months. The new system we are building is in full compliance with the existing regulations regarding banking software, and has already passed the first stage of certification to be cleared for use in banking institutions. It has also passed a series of tests in Prod with TLA+ and Haskell.
Teck stack employed: C++, a large number of licensed software components
Subtask 1: The upgrade should help reduce the cost of transactions handled by the system by $0.04 on average.
Subtask 2: Existing microservice architecture integrated with the legacy system should be preserved while legacy components should be replaced with new solutions.
Subtask 3: Bank staff should be able to operate the system without having profound IT skills.
Legacy tech stack: Perl, ANSI C99, COBOL (a rare version).
The legacy data storage and asset management system had an intricate and mottled structure where different components had been built at different times and with different tech stacks. While upgrading it, we were to preserve a large number of interfaces that had been built and integrated with the system over the past 20 years.
We advised our client to phase out the part of their system that was responsible for data storage and inventory. We would replace it with our own custom-built, turnkey solution, which was a multi-node data processing system with a pre-selected set of consistent operations grouped into families of mutually disjoint sets. It can analyze sequences of events, user groups or separate transactions.
We have been working on this project since 2016. Analyzing the legacy system alone took almost five months. The new system we are building is in full compliance with the existing regulations regarding banking software, and has already passed the first stage of certification to be cleared for use in banking institutions. It has also passed a series of tests in Prod with TLA+ and Haskell.
Teck stack employed: C++, a large number of licensed software components
Case 7
Fintech
high performance
backend
Compiling Cryptography to Wasm
Task: Build a user data processing system for an online payment service where sensitive data would be processed on the client side without being transmitted online. The solution must:
a) work in a browser,
b) work fast,
c) stick to a deterministic computational process.
Solution: Compile cryptographic libraries from their native programming languages to WebAssembly.
The client’s existing system would process user data on the server side using JavaScript, with critical data being transmitted over the network. Our job was to enable secure data processing in a browser on an end user’s PC or mobile device. We took a ready-made cryptographic library written in C++/Rust and compiled its code into a Wasm file using Emscripten, applying a compilation rule that ensured a deterministic computational process.
Our hardest task was to ensure that computations would be executed identically on the server, in the browser and on the user’s Android device, following all the rules for converting data type models from LP64/LLP64 to ILP32. To achieve this, we manually enhanced many of the cryptographic functions.
Using WebAssembly enabled us to accomplish the task meeting all of its requirements in the most efficient and the least labor-intensive way. Our solution enables data processing in a browser or on the end user’s device without any sensitive data being transmitted over the network, and each functional segment requires fewer IT specialists on the client’s side.
a) work in a browser,
b) work fast,
c) stick to a deterministic computational process.
Solution: Compile cryptographic libraries from their native programming languages to WebAssembly.
The client’s existing system would process user data on the server side using JavaScript, with critical data being transmitted over the network. Our job was to enable secure data processing in a browser on an end user’s PC or mobile device. We took a ready-made cryptographic library written in C++/Rust and compiled its code into a Wasm file using Emscripten, applying a compilation rule that ensured a deterministic computational process.
Our hardest task was to ensure that computations would be executed identically on the server, in the browser and on the user’s Android device, following all the rules for converting data type models from LP64/LLP64 to ILP32. To achieve this, we manually enhanced many of the cryptographic functions.
Using WebAssembly enabled us to accomplish the task meeting all of its requirements in the most efficient and the least labor-intensive way. Our solution enables data processing in a browser or on the end user’s device without any sensitive data being transmitted over the network, and each functional segment requires fewer IT specialists on the client’s side.
Case 8
frontend
high performance
Migrating an Online Game to a New Tech Stac
Task: Migrate server software of multiplayer online games from Perl and Postgres to a new tech stack to enable more efficient server utilization.
Tech stack employed: Python, C++, Lua, MongoDB, Tarantool.
The game application originally used Perl as its main backend programming language, while JavaScript and Lua were used for describing plot additions. We migrated most of the infrastructure to Python and C++ while preserving and keeping intact the existing game mechanics and scenarios. We migrated the client’s databases from MySQL to MongoDB, and used the Tarantool in-memory computing platform as hot cache and queue system.
Migrating to a new tech stack enabled the application to process incoming user traffic more efficiently and increase the game servers’ throughput capacity while using less infrastructure.
Tech stack employed: Python, C++, Lua, MongoDB, Tarantool.
The game application originally used Perl as its main backend programming language, while JavaScript and Lua were used for describing plot additions. We migrated most of the infrastructure to Python and C++ while preserving and keeping intact the existing game mechanics and scenarios. We migrated the client’s databases from MySQL to MongoDB, and used the Tarantool in-memory computing platform as hot cache and queue system.
Migrating to a new tech stack enabled the application to process incoming user traffic more efficiently and increase the game servers’ throughput capacity while using less infrastructure.
Case 9
Backend
high performance