LogNNet: Chaotic Reservoir-Computing Classifier

• LogNNet is a reservoir-computing classifier that uses deterministic chaotic mappings to project inputs into a high-dimensional feature space.
• It generates reservoir weights algorithmically, ensuring low memory usage while delivering efficient classification for resource-constrained devices.
• Performance improvements are linked to optimal chaotic regimes, validated by metrics such as Lyapunov exponents and approximate entropy.

The LogNNet Reservoir-Computing Classifier is a neural network architecture that integrates ideas from reservoir computing and chaotic dynamical systems to enable efficient, high-dimensional input transformation and lightweight classification. Designed for resource-constrained environments such as IoT devices and embedded systems, LogNNet achieves strong performance in pattern recognition, time-series processing, and classification while maintaining low memory and computational footprint.

1. Architecture and Reservoir Mapping

LogNNet employs a feedforward network structure comprising an explicit "reservoir" stage and a linear classifier. The reservoir is instantiated as a fixed-weight, pseudo-random, or chaotic projection from the input space to a higher-dimensional intermediate space. Unlike traditional recurrent reservoirs, LogNNet utilizes deterministic chaotic mappings to generate the reservoir weight matrix either on-the-fly or via algorithmically constructed kernels, obviating the need for large static weight storage (Velichko, 2020, Izotov et al., 2021, Izotov et al., 31 Aug 2025).

The transformation pipeline can be described mathematically as follows. For an input vector $Y \in \mathbb{R}^{N+1}$ (with the first component for bias), the reservoir output $S$ is

$S = W \cdot Y$

where $W$ is a reservoir matrix filled using a deterministic, typically chaotic, mapping such as

$x_{n+1} = 1 - r(x_n)^2$

or, in improved versions, a semi-linear Henon type map:

$$\begin{align*} x_{n+1} &= y_n \ y_{n+1} &= x_n + a_1 x_n^2 + a_2 y_n^2 - a_3 x_n y_n - a_4 \end{align*}$$

(Heidari et al., 2021). The initial sequence (for each row) may be seeded using a sine function or constants, and the matrix is filled in a deterministic rule-driven fashion.

The resulting intermediate vector $S$ is further normalized and expanded with an additional bias entry to form $Sh$, which feeds into one or more classification layers.

2. Chaotic Kernels and Their Role

A defining feature of LogNNet is its use of chaotic mappings to construct the reservoir. The kernel weights $W_{i,j}$ are computed recursively using low-dimensional maps (such as the logistic or Henon map), resulting in a high-dimensional, highly mixed projection. This approach introduces controllable chaos, quantified via metrics like the Lyapunov exponent or approximate entropy (ApEn), which strongly correlates with improved classification accuracy (Velichko, 2020, Heidari et al., 2021). Empirical studies confirm that optimal performance is achieved when the system operates in a strongly chaotic regime, as measured by positive Lyapunov exponents.

Key parameters (e.g., $r$, $a_i$, initial conditions) dictate the degree of "mixing" and feature dispersion in the reservoir. Optimization of these parameters (e.g., via particle swarm optimization with random immigrants) further enhances accuracy while maintaining the compactness of the representation (Heidari et al., 2021).

3. Memory Efficiency and Embedded Implementation

LogNNet is engineered for low-memory deployments. Instead of storing a full matrix $W$, reservoir weights are generated algorithmically just-in-time, using either:

• Single-value recurrences (for minimal memory, but slower computation),
• One-dimensional auxiliary arrays (balance of speed and RAM),
• Or, if memory allows, a precomputed two-dimensional array (maximal speed).

RAM requirements range from approximately 1 kB (for a 25-neuron reservoir) to 29 kB (for larger configurations), with applications on microcontrollers such as Arduino (2 kB RAM) and ARM Cortex devices (32 kB RAM) (Izotov et al., 2021, Izotov et al., 31 Aug 2025). All critical network parameters and classifier weights are stored in compact header files, ensuring total memory efficiency.

For example, the LogNNet-784:20:10 model (MNIST, 20 reservoir neurons, 10 classes) successfully runs on an Arduino UNO with 1.6 kB RAM, achieving ∼82% accuracy and recognizing digits without image downsampling or preprocessing (Izotov et al., 2021). For speech command recognition, a 64:33:9:4 architecture achieves 92% accuracy on the Arduino Nano 33 IoT, with total RAM usage of 18 kB (55% of available memory) (Izotov et al., 31 Aug 2025).

4. Classification Performance and Applications

LogNNet has demonstrated strong, often competitive, classification performance across a range of tasks:

Application Domain	Architecture	Dataset/Task	Accuracy (%)	Memory Usage (RAM)
Digit Recognition	784:100:60:10	MNIST-10	96.3	Up to 29 kB
Digit Recognition	784:20:10	MNIST-10 on Arduino	82	1.6 kB
Speech Commands	64:33:9:4	4 commands, SC dataset	92	18 kB
Perinatal Assessment	25:100:40:3	Cardiotocogram, UCI	91	10 kB
COVID-19 Propensity	8:6:4:2 / 8:16:10:2	Israeli MoH symptoms	95	0.6–0.8 kB

Key findings include:

• Accuracy increases with reservoir richness, up to a task-dependent plateau.
• Low memory footprint enables on-device classification without cloud connectivity.
• The performance of the classifier is tightly linked to the chaoticity (entropy, Lyapunov exponent) of the reservoir kernel (Velichko, 2020, Heidari et al., 2021).
• Output layers are lightweight (shallow, typically linear or with a small nonlinearity) and trained using standard methods (e.g., backpropagation or pseudoinverse).

5. Generalization, Optimization, and Robustness

Reservoir-based classification in LogNNet benefits from the separation offered by chaos-induced high-dimensional projections. Functional performance is characterized not only by direct accuracy but by robustness to reservoir parameter changes, noise, and data variability. Chaotic mapping creates a "feature kernel" akin to the kernel trick in support vector machines, enabling linear classifiers to separate classes otherwise inseparable in the input space.

Optimization methods (particle swarm with random immigrants) target the reservoir's parameters to maximize metrics such as entropy and accuracy. The direct correlation between approximate entropy and classification performance empirically validates the premise that maximizing the chaoticity of the reservoir enhances generalization (Heidari et al., 2021).

6. Practical and Theoretical Implications

LogNNet exemplifies a design trend in reservoir computing: using explicit, algorithmic, and often chaotic transformations to replace learned or hardware-intensive recurrent architectures. The architecture is resource-efficient, suitable for edge computing, and enables real-time analytics for a wide range of signals without preprocessing or dimensionality reduction.

LogNNet’s approach is in line with contemporary findings on the sufficiency of weak nonlinearity and high-dimensional random projections in random neural networks for complex classification. The theoretical foundation rests on random feature theory and the insight that chaotic dynamical maps provide effective mixing in minimal hardware or software (Gonon et al., 2023, Metzner et al., 15 Nov 2024).

This combination of fixed, chaos-driven kernels and minimal trainable parameters demonstrates that sophisticated nonlinear representations and high accuracy can be achieved with architectures tailored for strict size and energy budgets. Implementations in domains such as medical diagnostics, speech command interfaces, and portable smart sensors illustrate the practical scope.

7. Extensions and Future Directions

Advancements include the use of alternative chaotic mappings (semi-linear Henon, Gauss, modified Henon) to further optimize the feature space (Heidari et al., 2021, Velichko, 2021). Ongoing developments focus on:

• Fine-tuning chaotic parameters for specific data domains,
• Combining or alternating kernels for hybrid feature transformations,
• Implementing adaptive strategies to adjust the reservoir’s dynamical regime for task specificity, following the "edge-of-chaos" principle (Metzner et al., 15 Nov 2024),
• Enhancing robustness to missing or noisy input features in real-world medical and sensor datasets (Velichko, 2021).

A plausible implication is that future low-resource classifiers for embedded AI will leverage such deterministic, entropy-optimized kernel generation for efficient and adaptive on-device intelligence.

---

In conclusion, the LogNNet Reservoir-Computing Classifier represents a reservoir-based learning paradigm that fuses chaotic dynamics with lightweight feedforward architectures to deliver efficient, accurate, and resource-aware neural classification suitable for edge AI, healthcare analytics, and embedded intelligence (Velichko, 2020, Izotov et al., 2021, Heidari et al., 2021, Velichko, 2021, Izotov et al., 31 Aug 2025).