DETECTION

TAPe+ML is a platform for building and running computer vision solutions. It lets you work with your own images, train a model for the object classes you need, check the results and connect recognition to your product or workflow.

The platform is built on the TAPe+ML architecture for detection, classification and segmentation. Here you can test a task on your own data, train a model and use it in the cloud, on your company's infrastructure or on an edge device.

Conventional CV models take an image as an array of pixels, and inside the neural network they reconstruct the structure of the scene and recognise objects at the same time. This often takes large models, large datasets and substantial computing resources.

TAPe+ML first builds a structured representation of the image – its meaningful elements and the relationships between them. The model then works with that structure. This is why TAPe+ML reaches SOTA quality in detection, classification and segmentation without inflating the model to tens or hundreds of millions of parameters.

A compact model is easier to deploy where it is impossible or pointless to dedicate powerful GPU infrastructure to recognition: on a local server, next to a camera or as part of a device.

For an integrator this widens the deployment options; for a company it lowers infrastructure requirements and makes it easier to scale the solution across multiple cameras, devices or sites.

No. In our comparisons TAPe+ML outperforms SOTA models in detection and segmentation while remaining a model of fewer than 100 thousand parameters. On COCO it beats RF-DETR 2XL and YOLO in detection, and YOLO in segmentation in terms of object mask coverage. Detection, classification and segmentation all run on one compact core – without a separate heavy stack for each task.

Not necessarily. TAPe+ML runs on CPU and outperforms SOTA models in our comparisons without a GPU for inference.

This lets you run recognition on ordinary servers, local devices and edge hardware – without the mandatory cost of a permanent GPU setup. You can use a GPU if needed, but TAPe+ML does not require one.

The published TAPe+ML CPU benchmarks were obtained on a server with an Intel Xeon E5-2697 v2 @ 2.70 GHz processor and 256 GB of DDR3 1600 MT/s, in single-threaded mode with SIMD.

This is not a specialised GPU server: the results show that a CPU is enough for SOTA-level recognition with TAPe+ML. On other hardware, speed depends on image resolution, the number of objects in the frame and the selected task.

Yes. The platform is not only for ML engineers. You can start by testing your task on images and discussing the object classes you need. You do not have to build separate infrastructure for annotation, training and inference beforehand.

If your company already has an ML team, it can use TAPe+ML as the basis for its own model and for integration into an existing product or process. Technical details on working with data and the API are covered in separate documentation.

Yes. TAPe+ML can be trained to recognise your objects even if you only have a few dozen images per class so far. This lets you start working with your own data without first collecting thousands of examples.

Yes. TAPe+ML can be adapted to domains where typical models perform poorly: non-standard objects, complex textures, specific lighting, small defects or industrial scenes.

In an industrial pilot on detecting ore contamination, TAPe+ML trained on 30 images and two classes delivered a result suitable for further deployment, while a baseline YOLO on the same task achieved about 28% accuracy according to the customer's data.

No. Start by annotating the first images, then use the model's predictions to speed up further annotation. The platform suggests detections on new images: you confirm or correct them, and the dataset and the model improve from iteration to iteration.

This reduces manual work and helps you get from the first examples to a trained model faster.

You can start with a few images and the first annotated examples. The platform lets you quickly check whether the model recognises the objects you need, and then improve the result on your data.

For suitable tasks, getting from the first examples to a working dataset takes minutes, not weeks of preparing a separate ML stack.

TAPe+ML supports three key computer vision tasks:

• Object detection – determines which objects are in the image and where they are.
• Classification – assigns an image or an object to the right category.
• Instance segmentation – outlines the exact area of each object in the image.

The right mode depends on the application. Detection is often enough for counting and finding objects; classification for checking what kind of object it is; segmentation for estimating shape, area or exact boundaries.

Yes. TAPe+ML can be applied in visual quality control scenarios if the relevant features are visible in the image: defects, a missing component, incorrect position, damage, non-conforming shape or labelling.

The solution should be tested on real data: camera type, lighting, object movement speed, defect types and the acceptable error rate. This shows whether an off-the-shelf model, custom training or an integration project is the right fit.

Yes. Possible scenarios include recognising products and packaging, shelf compliance monitoring, object counting, damage detection, analysis of warehouse operations and monitoring the movement of objects.

Each scenario has its own object classes and shooting conditions. So the base model can be used for an initial test, while for a production task the solution can be adapted to the required product range, cameras and process.

TAPe+ML can be considered for tasks that require analysing a visual stream: detecting and classifying objects in the frame, monitoring events or tracking changes.

However, the video analytics format is determined by the specific process: the number of cameras, resolution, frame rate, acceptable latency, how data is stored and how the system responds to the result. These parameters should be evaluated in a pilot before deployment.

Yes. TAPe+ML is designed for scenarios where recognition runs close to the data source: a camera, equipment or a local computing system. This can matter when you need to reduce latency, send fewer images to the cloud or work over an unstable connection.

Compatibility with a specific device is confirmed separately, taking into account its computing resources, camera parameters, load, speed requirements and how the model is updated.

Yes. Connect TAPe+ML via the API so that your application receives recognition results and uses them in its own logic. For example, a quality control system can pass information about a detected defect to an operator, log the event or trigger the required action.

TAPe+ML can be embedded into a corporate system, a production environment, a customer service or a system integrator's solution.

TAPe+ML integrates via standard HTTP requests. Your application sends an image or video for recognition and receives the result in a YOLO-compatible format.

So the programming language does not matter: TAPe+ML can be connected to a project in Python, C++, JavaScript, Java or any other language that can send HTTP requests.

In API mode, requests are processed on the TAPe+ML server. With an on-premise deployment, requests go to a local address inside your infrastructure – without data passing through the internet.

These are the TAPe+ML deployment options:

• Cloud / SaaS – a quick start and work through the cloud environment.
• On-premise – the solution is hosted inside the customer's infrastructure.
• Edge – local inference close to the data source, such as a camera or equipment.

The API is not a separate environment but a way to connect TAPe+ML capabilities to your own application or system. The choice of option depends on your requirements for data, network, latency, security and support.

Yes. TAPe+ML can be deployed inside your company's infrastructure: images and video are processed locally, with no mandatory transfer to the cloud.

This format suits production systems, internal services and other tasks where data must stay within the corporate perimeter. The level of data protection and compliance with company requirements depend on the chosen deployment configuration.

No. You can prepare data, train a model, check the result and connect recognition via the API – without having to put together several separate tools for it.

If you already have your own CV stack, there is no need to rebuild it. You can embed TAPe+ML into your existing solution and use our architecture for your task.

Yes. System integrators and product IT teams can use TAPe+ML as a component of a client solution or of their own product. This is relevant when you need to add recognition without building a separate CV stack from scratch.

The working format – API, cloud access, local hosting or an edge scenario – depends on the architecture of the final solution and the customer's requirements.

Choose a plan and start with the ML workbench. It gives you enough tokens to test recognition on ready-made models and COCO datasets, and then to create your own model: upload images or video, annotate the data, train the model and connect it to your system via the API.

This way you can test TAPe+ML on a real task and compare the result with your current solution. If you plan to work with video, choose the Med plan.

For on-premise, edge and integration scenarios, submit a deployment request by email or here.