Information, Computing and Intelligent systems

Implementation of difference of Gaussians based on all-pass IIR filter with C-slowing

2026-04-02T10:25:55+03:00

The research analyses the computational efficiency of image processing algorithms on GPUs. The primary focus of this work is the Difference of Gaussians (DoG) stage of the scale invariant feature transform algorithm. The study aims to overcome existing computational time limitations associated with Finite Impulse Response (FIR) implementations. To solve this, both Infinite Impulse Response (IIR) with all-pass filtering applied and C-slow retiming are proposed. An experimental framework was developed and tested on NVIDIA CUDA GPUs: RTX 3090, 4090, and 5090. Thus, FIR convolution kernels were compared with the IIR implementations using various C-slowing factor values.

Experimental results confirmed theoretical modelling that FIR computation time scales with the kernel size, whereas IIR computation time is independent of it. Therefore, IIR provides lower computational time and higher throughput without regression in visual quality. Further experiments revealed that C-slow retiming introduces overhead that outweighs its benefits and limits its use on modern high-end GPUs, contrary to theoretical expectations. However, using C-slow retiming on low-performance devices could yield more beneficial results. The scientific novelty lies in the experimentally validated use of all-pass IIR filters as a computationally lower alternative to traditional approaches for real-time DoG implementation on modern GPU architectures.

Model and method of balanced partitioning and route optimization for multi-unmanned aerial vehicle task planning

2026-03-27T19:27:20+02:00

This study addresses centralized mission planning for heterogeneous UAV fleets that perform a single sortie from a common depot to service spatially distributed tasks. The study develops a deterministic planning framework for asymmetric and weakly non-metric travel costs. The framework supports early feasibility control, workload balance, and route-quality improvement. The research materials consist of benchmark mission instances defined by task locations, dwell times, endurance limits, and precomputed directed cost matrices for each UAV. The methods include feasibility masking of task–vehicle assignments, workload balancing with an order-independent surrogate load, and weighted power partitioning with deterministic offset updates. They also include single-vehicle route optimization and exchange-based refinement under a composite objective of total fleet cost and makespan. The results show that the first stage provides a strong trade-off between balance and efficiency while preserving spatial coherence. The second stage yields consistent additional reductions in makespan and in the composite objective with modest computational overhead. Across the benchmarks, the framework maintains near-minimal total cost while markedly reducing the longest route relative to cost-greedy assignment. The study shows that localized route-level refinement improves solution quality without repeated low-level replanning. Early feasibility control is incorporated at the allocation stage. The scientific novelty consists in establishing that cost-matrix-aware workload allocation reduces route-cost imbalance before route sequencing under UAV-specific directed costs. The study also shows that route-level correction under the same cost representation further reduces makespan and the composite mission objective.

A method for accelerating perceptron computations on FPGA based on online arithmetic for convolutional neural networks

2026-03-31T23:44:59+03:00

Approaches to accelerating result formation in a perceptron implemented on a field-programmable gate array (FPGA) through the application of online arithmetic in a redundant number system have been investigated. The classical parallel implementation of a neural computational path exhibits nonlinear latency growth as operand bit-width and input count increase, due to carry propagation in wide adder trees. The object of study is the complete hardware computational path of the perceptron – from parallel multiply operations to the threshold activation function – as well as its integration as a functional block of a fully connected classifier (FC) within a convolutional neural network (CNN). The aim is to design and verify an architecture that enables overlapping of dependent computation stages while reducing the load on critical hardware resources compared to the parallel approach, under the constraint of preserving a deterministic output-latency profile. The methodological basis encompasses analytical latency modelling with consideration of the online delay parameter p, synthesis of an online multiplier with redundant coding and a 3:2 adder tree, and systematic comparison of the two paradigms across timing and hardware metrics. Verification was performed via hardware simulation in Active-HDL and synthesis with timing closure in Quartus on the Altera Cyclone III EP3C5E144 platform. A speedup of 2.29× was achieved for a configuration with 64 inputs and 16-bit operands at 200 MHz; the input load on the first adder-tree level was reduced by 62.5%; DSP blocks were reduced from 64 to 24 with a moderate increase in flip-flops (from 9180 to 9720). The scientific novelty lies in the proposed unified architectural model that combines online arithmetic and redundant coding, simultaneously reducing latency, lowering hardware resource use, and ensuring stable real-time operation.

Video object detection method based on Looking Fast and Slow and YOLO

2026-01-22T14:11:04+02:00

This paper explores the importance of using temporal context in object recognition in video streams to improve accuracy and inference time. Common approaches to the real-time object detection process frame independently of each other. These limitations lead to unstable predictions and the need for more complex neural networks. The Looking Fast and Slow method addresses this limitation by introducing temporal memory. However, its original implementation relies on outdated backbone networks. which restricts its accuracy and practical applicability. The aim of this research is to improve the accuracy of the Looking Fast and Slow method by adapting it to modern YOLO-based object detection architecture, preserving real-time performance. The study analyzes modern approaches to video object detection, highlights their advantages and limitations and justifies the choice of improving the Looking Fast and Slow method. Based on this analysis, an enhanced YOLO-based model was proposed to achieve the goal. Flexible architecture for the data preparation stage and proposed training procedure allows fine-tuning or retraining models with minimal effort. The scientific novelty of the result lies in the combination of the Looking Fast and Slow method and the YOLO method, which improves its accuracy and maintains real-time performance. Experiments on the PASCAL VOC dataset and a subset of YouTube-8M demonstrate that the proposed model outperforms single-frame YOLO by up to 4.3 mean average precision (mAP) metric and the original Looking Fast and Slow by up to 12.4 mAP. It was investigated which hyperparameters provide the best trade-off between accuracy and speed using a dedicated combined metric. Future improvements were discussed that will enable even better accuracy and inference speed. The proposed approach provides a practical basis for further research in the field of object detection.

Decentralized leader election protocol for unmanned ground vehicle swarms in dynamic environments

2026-04-14T17:39:59+03:00

Unmanned ground vehicle swarms are gaining relevance as the foundation of autonomous systems capable of effectively operating in dynamic conditions. However, reliability issues constrain their widespread adoption. Traditional navigation algorithms based on a static leader model create a single point of failure, increasing formation vulnerability to hardware failures, depletion of energy resources, and unpredictable terrain changes. This paper investigates the process of autonomous swarm navigation based on a two-dimensional environment simulation model. The research aims to improve efficiency and fault tolerance by developing a decentralized protocol for swarm leader election. The proposed protocol is integrated into a hybrid navigation method, described in the authors’ previous works. It combines planning (using A* algorithm and artificial potential fields) and stabilization (hysteresis and artificial vortex field). The scientific novelty is the multi-parameter utility function for the protocol, which considers the vehicles’ energy, terrain traversal cost, proximity to the goal, and a safe distance to obstacles. Integrating the protocol into the specified hybrid method ensures an adaptive role distribution in the swarm within a dynamic environment. The simulation findings confirmed that the developed protocol’s integration into the hybrid navigation method increases fault tolerance. It enables the swarm to overcome local minima during leader failures under moderate communication interference (up to 60% packets lost). Experiments indicate that transferring control to followers in better conditions increases efficiency by reducing the total time for passing high-cost traversal zones. Comparative analysis demonstrates its advantage over a fixed-leader approach: for a 5-vehicle swarm, the total traversal time is reduced by 3% and the formation mean squared error by 8%.

Concept for software design based on autonomous objects and integrated thread control

2026-04-14T15:35:21+03:00

Modern object-oriented programming faces a serious challenge of excessive architectural complexity and high cognitive load on developers, which frequently leads to design errors. This research presents a reimagined programming concept aimed at a radical simplification of software development through the implementation of autonomous computational units. Traditionally, developers struggle with blurred logic in hierarchical inheritance trees, which often results in unpredictable system behavior and the "fragile base class" problem. At the core of this proposed approach is the total rejection of traditional inheritance in favor of a model based on structural nesting and active encapsulation. In this paradigm, an object becomes a self-sufficient "black box" through the "object as code" concept, which identifies the object body with its constructor to eliminate the gap between structural description and initialization logic. Particular attention is paid to the multithreading mechanism, addressing the traditional struggle with manual synchronization that often leads to data integrity violations. Threads in this architecture function as independent, self-synchronized units that automatically create isolated memory copies for execution. This effectively eliminates the need for complex external locking primitives like mutexes or critical sections through implicit method locking. Additionally, the study integrates the "each" operator into the language core for deterministic time management, allowing periodic processes to run using independent copies of internal variables to ensure execution consistency without cumbersome callback functions. Ultimately, this concept establishes a robust foundation for next-generation programming languages that combine declarative simplicity with high autonomous execution safety and reduced cognitive barriers for developers.

Models for allocating students to free elective courses

2026-04-14T18:48:18+03:00

The article is devoted to the development of mathematical models for allocating students to free elective courses in higher education institutions under conditions of limited capacity. The relevance of the study is determined by the need for transparent and formalized allocation mechanisms. Unlike early registration procedures, these mechanisms account for not only the order of application submission but also students’ individual preferences and their priority based on an integral rating score. The aim of the study is to develop and provide a theoretical justification for mathematical models for allocating students to free elective courses. It also aims to identify the specific features of applying weighted and lexicographic approaches to such allocation. The study employs methods of discrete and lexicographic optimization. The allocation problem is formalized with due regard to course capacity constraints, the number of courses selected by each student, and feasibility conditions. Four mathematical models are constructed, combining ranked lists and normalized weight coefficients with two approaches to incorporating student priority, namely weighted and lexicographic. The experimental validation is carried out using generated data for 1000 students and 30 courses, using Monte Carlo simulation. It is established that the weighted models provide a more balanced allocation and a higher level of student satisfaction, whereas the lexicographic models ensure stricter adherence to the hierarchy of priorities. The scientific novelty lies in the development of a set of models that allow accounting not only the order but also the intensity of students’ individual preferences. The practical significance of the results lies in the possibility of using the proposed models as a basis for creating transparent decision-support mechanisms in higher education institutions.

Formal model of error escalation and recovery in multilayer asynchronous architectures with an event loop

2026-05-18T11:53:31+03:00

Layered asynchronous architectures with an event loop combine intra-process scheduling, worker-thread execution, child-process isolation, and network interaction. Their reliability depends on how failures are represented, escalated, recovered, and converted at architectural boundaries. The object of this study is error escalation and recovery in such architectures. The purpose is to increase the reliability of layered asynchronous systems by developing and empirically evaluating a formal model that links error representations, escalation boundaries, recovery strategies, and overhead within the Imperative Shell/Multi-Paradigm Core pattern. The study uses formal comparison of error-representation contracts, boundary analysis of event-loop, worker-thread, child-process, and network communication, architectural modelling, and reproducible microbenchmarking on the Node.js platform. The proposed model includes a taxonomy of four error representations: thrown exceptions, error-first callbacks, the Result monad, and typed error codes. It also defines escalation semantics for event-loop phases and process, worker, and network boundaries. The model assigns total value-based computation to the multi-paradigm core and side-effectful recovery, logging, retry, circuit breaking, compensation, supervision, and protocol conversion to the imperative shell. Empirical evaluation shows that thrown errors are hundreds of times more expensive than value-typed alternatives, that retry and circuit-breaker wrappers add only tens of nanoseconds on the successful path, and that worker restart latency is about 20 ms. The scientific novelty lies in combining representation taxonomy, boundary-sensitive escalation semantics, recovery-strategy placement, and measurable overhead into one formal model. The obtained recommendations support the design of fault-tolerant Node.js systems.

Software technology for clustering states by feature similarity based on self-organizing Kohonen maps

2026-04-19T12:33:59+03:00

This paper presents a software technology for clustering high-dimensional states by feature similarity, based on Kohonen self-organizing maps with L2 normalization of binary feature vectors. The technology is realized by autors as Dr.Case program system, a layered software system for automated differential medical diagnosis. The study provides a theoretical foundation for the L2 normalization step in the form of two theorems. The first identifies a systematic bias of the unnormalized Euclidean metric toward the cardinality of binary profiles. The second shows that L2 normalization removes this bias and reduces the pairwise Euclidean distance between binary inputs to a function of structural (cosine) similarity alone. On a database of 844 diseases and 460 symptoms, L2 normalization reduces the self-organizing map quantization error from 2.79 to 0.82. These Quantization Error values measure distances in different geometries and are not directly comparable as absolute distances. Normalization also reduces the topographic error from 0.28 to 0.13 and increases the map fill ratio from 37 percent to 79 percent. The software system combines self-organizing map clustering with a candidate selector and a two-branch disease-ranking neural network trained with Focal Loss and Label Smoothing. These components are integrated by an iterative diagnostic cycle with Expected Information Gain question selection, specificity-aware Bayesian answer processing, and rule-based reinforcement for highly specific disease features. The implementation is organized in 16 Python modules with a REST API and a web user interface. The self-organizing map index together with the candidate selector covers 99.5 percent of the 844 disease catalogue under self-projection (840 of 844 diseases). On a small held-out demonstration set of six clinical cases, the end-to-end system reaches 83.3 percent Top-1 accuracy.