A Hierarchical Event‐Oriented Stochastic Processor for Continuous Monitoring of Event Probabilities

1. Introduction

Stochastic computing (SC) is an unconventional computing paradigm in which numerical values are represented by probabilities encoded in random or pseudo-random bitstreams. In the unipolar representation, a value $x\in \left[\mathrm{0,1}\right]$ is encoded as the fraction of logical ones in a Bernoulli bitstream, while arithmetic and functional operations can be implemented using simple logic structures. This principle has been widely studied in the context of compact arithmetic, approximate computing, neural-network implementation, and energy-efficient hardware [1,2,3,4]. In particular, multiplication can be implemented by an AND gate when statistically independent stochastic streams are used, while addition, selection, and more complex operations can be implemented using multiplexers, finite-state machines, correlation-aware structures, and polynomial-function approximations [3,4,5,6,9,13,16].

The simplicity of stochastic logic is accompanied by important practical limitations. The accuracy of a stochastic estimate depends strongly on the bitstream length, and long streams may be required to reduce statistical error [4,5,6,11]. Moreover, correlation between stochastic streams can either degrade or intentionally improve computation depending on the target operation: multiplication generally requires uncorrelated streams, whereas mean circuits and some inner-product structures may benefit from controlled positive correlation [9,12,13,15,16]. These issues make bitstream length, correlation management, stream generation, and synchronization central design constraints for any processor-level stochastic architecture. Recent studies on deterministic and quasi-stochastic approaches, in-stream correlation manipulation, down-sampling, and adjustable sequence length further confirm that accuracy, latency, and stream-management complexity remain active challenges in SC [6,11,12,18].

SC has also attracted considerable attention in neural and approximate computing. Stochastic implementations of convolutional neural networks, memristive and spintronic SC systems, ReRAM-based in-memory stochastic computing, and Bayesian or quantized neural-network architectures demonstrate that SC can support compact and energy-efficient inference under controlled accuracy degradation [1,7,8,17,18,19,20]. However, most of these works treat SC primarily as a set of arithmetic or neural-network-oriented building blocks. Less attention has been paid to stochastic processor architectures that continuously operate on event probabilities produced by heterogeneous physical signals.

In parallel, optical and photonic implementations of stochastic and probabilistic computing have emerged as an important research direction. Integrated optical stochastic computing architectures and the OSCAR optical stochastic accelerator demonstrated the feasibility of implementing SC functions in optical platforms [21,22]. Photonic-crystal nanocavity architectures have further shown all-optical stochastic logic operations such as XOR and MUX, as well as cascaded stochastic processing and bitstream-length analysis [23,24]. More broadly, probabilistic photonic computing, photonic Bayesian neural networks, optical noise-assisted inference, stochastic photonic spiking neurons, and probabilistic photonic machine-learning systems indicate that photonic hardware can support stochastic or probabilistic information processing using physical randomness, optical noise, or chaotic light [25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40]. These developments provide a strong technological context for future optical, photonic, or hybrid implementations of stochastic processors.

At the same time, optical logic gates and photonic combinational circuits provide a hardware-level basis for constructing more complex optical processing blocks. Photonic implementations of AND, OR, NOT, NAND, NOR, XOR, XNOR, multiplexers, half adders, full adders, code converters, and programmable photonic logic arrays have been reported using photonic crystals, inverse-designed metamaterials, Mach–Zehnder interferometers, micro-ring resonators, nonlinear photonic waveguides, and diffractive optical neural structures [41,42,43,44,45,46,47,48,49,50,51,52,53,54]. These works show that optical logic gates can serve as elementary building blocks for higher-level photonic circuits. However, the transition from optical logic gates or stochastic optical modules to a continuous, event-oriented stochastic processor remains largely unexplored.

The motivation for the present work arises from this gap. In many sensing and monitoring tasks, the relevant output is not a deterministic number or a single class label, but the time-dependent probability of a target event. Event-based and event-oriented sensing systems already address asynchronous signal acquisition, complex event processing, low-power long-term monitoring, event-triggered estimation, sensor fusion, and neuromorphic event streams [55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74]. These approaches are particularly useful when signals are sparse, irregular, asynchronous, or continuously monitored. Nevertheless, event probabilities in these systems are usually processed at the software or algorithmic level rather than represented as hardware-compatible stochastic bitstreams in a processor architecture.

A direct mapping of physical signal features into Bernoulli bitstreams leads to another scalability problem. A single physical channel may produce many low-level features. For example, an acoustic signal may be described by amplitude, dominant frequency, spectral structure, modulation, repetition, duration, timbre-related descriptors, similarity to warning patterns, and source-class probabilities. Encoding each of these quantities as a separate stochastic stream rapidly increases the number of required input streams, synchronization paths, stochastic logic blocks, and physical channels. This becomes especially problematic when multiple sensing modalities are used simultaneously.

For this reason, the present work proposes a hierarchical event-oriented stochastic processor architecture for continuous monitoring of event probabilities. Instead of directly converting all low-level physical features into separate stochastic streams, the proposed architecture introduces local event-probability formation blocks. Each local block converts a group of task-relevant features from a physical channel into a compact set of local event probabilities. These local probabilities are then encoded as Bernoulli bitstreams and processed by a stochastic event-fusion core. The processor output is not a single static value, but a time-resolved global event-probability signal,

$$P_{event}(t),$$

which enables temporal analysis of persistence, repetition, trend, and accumulated exposure.

The acoustic channel is used in this preprint as an illustrative proof-of-principle case. Acoustic event detection, sound event detection, acoustic scene classification, siren and alarm detection, emergency-vehicle sound recognition, and urban sound monitoring are mature research areas [75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92]. DCASE-related studies have established standard formulations for acoustic scene classification and sound event detection, including the distinction between scene-level classification and time-localized event detection [75,76,77,78]. Other works have addressed siren detection, emergency vehicle recognition, urban sound classification, multilabel acoustic event classification, and acoustic monitoring in real-world urban environments [79,80,81,82,83,84,85,86,87,88,89,90,91,92]. In the present work, these methods are not used to build a full-scale acoustic recognition system. Instead, the acoustic case is used to demonstrate how low-level physical features can be transformed into local event probabilities and then into Bernoulli event streams that feed a stochastic processor. Table 1 summarizes the main literature directions relevant to the proposed architecture and highlights the gap addressed in this work.

Based on this positioning, the present work treats stochastic computing not only as a set of local arithmetic primitives, but as a basis for a hierarchical processor architecture for continuous event-probability monitoring.

The main contributions of this work are as follows:

• A hierarchical event-oriented stochastic processor architecture is proposed for continuous monitoring of event probabilities.
• The concept of local event-probability formation blocks is introduced to reduce the direct expansion of physical features into many Bernoulli bitstreams.
• A stochastic event-fusion core is used to combine compact local Bernoulli event streams into a time-resolved global event-probability signal.
• A synthetic acoustic monitoring scenario is developed as an architecture-level proof of principle.
• Direct feature-to-bitstream mapping is compared with hierarchical event-probability mapping to illustrate the compression–accuracy trade-off.

The remainder of the paper is organized as follows. Section 2 describes the proposed hierarchical event-oriented stochastic processor architecture. Section 3 introduces the local acoustic event-probability formation model used in the proof-of-principle demonstration. Section 4 describes Bernoulli bitstream generation and stochastic event fusion. Section 5 presents the numerical experiment and time-resolved monitoring results. Section 6 discusses the compression–accuracy trade-off, limitations of the current demonstration, and possible extensions toward optical, photonic, and hybrid implementations. Section 7 concludes the paper.

2. Proposed Hierarchical Event-Oriented Stochastic Processor Architecture

The proposed architecture is intended for continuous processing of heterogeneous physical signals whose relevance is defined not only by their instantaneous values, but also by their contribution to a target event over time. In contrast to a conventional feature-level processing pipeline, where each extracted physical feature may be independently encoded and processed, the proposed processor first forms compact local event probabilities and then processes them as stochastic streams. This design is motivated by the observation that the number of low-level features can grow rapidly when each physical channel is decomposed into amplitude, spectral, temporal, statistical, and contextual descriptors. Directly converting all of these features into Bernoulli bitstreams would increase the number of streams, synchronization paths, stochastic gates, and physical channels required for implementation.

The overall structure of the proposed hierarchical event-oriented stochastic processor is shown in Figure 1.

The proposed processor is therefore organized hierarchically. Its first level consists of local event-probability formation blocks. Each block receives a set of features from one physical channel or from a closely related group of physical measurements. The function of this block is not to preserve all low-level features as separate processor inputs, but to convert them into a compact set of event-level probabilistic descriptors. For example, an acoustic block may convert sound energy, temporal modulation, repetition, and similarity to warning-like patterns into probabilities such as $p_{warning}(t)$, $p_{disturbance}(t)$, and $p_{confidence}(t)$. Similarly, a thermal block could convert temperature, rate of change, threshold duration, and local fluctuations into a thermal event probability, while an optical or smoke-related block could convert transmittance loss, attenuation slope, and fluctuation level into a smoke-event probability.

The second level of the architecture is the stochastic event-fusion core. Local event probabilities are encoded as Bernoulli bitstreams and processed using stochastic logic and functional operations. Depending on the target application, the fusion core may implement OR-like accumulation, AND-like confirmation, weighted fusion, thresholding, majority-like decisions, multiplexer-based conditional routing, or nonlinear activation-like transformations. The exact operation is task-specific, but the computational representation remains stochastic: probabilities are processed through bitstreams rather than only as deterministic floating-point values.

The third level is the temporal event-analysis layer. The output of the stochastic fusion core is interpreted as a time-resolved global event-probability signal,

$$P_{event}(t),$$

rather than as a single static output. This signal can then be analyzed in terms of persistence above a threshold, repeated event episodes, moving average, trend, accumulated exposure, and risk-state transitions. This temporal layer is essential for event-oriented monitoring, because two signals with the same instantaneous event probability may have different practical meanings depending on whether the event is isolated, repeated, or sustained over a long interval.

A high-level representation of the proposed architecture can be written as

$$x_i(t)\to {\varphi }_i(t)\to p_i(t)\to B_i(t)\to P_{event}(t),$$

(1)

where $x_i(t)$ denotes the raw or preprocessed signal from physical channel $i$, ${\varphi }_i(t)$ is the corresponding feature vector, $p_i(t)$ is a compact vector of local event probabilities, and $B_i(t)$ is the Bernoulli bitstream representation of these probabilities. The final output $P_{event}(t)$ is obtained by stochastic fusion of the local event streams.

In this formulation, the architecture is universal at the structural level but task-specific at the mapping level. The same processing sequence can be applied to acoustic, thermal, optical, vibration, gas, or other sensing channels. However, the mapping from features to local event probabilities must be designed and calibrated for each target event and application domain. Therefore, the processor does not rely on a universal feature-to-probability formula. Instead, it provides a general stochastic processing framework into which task-specific local event-probability formation blocks can be inserted.

2.1. Local Event-Probability Formation

The local event-probability formation block is the first computational level of the proposed processor. It converts a set of physical or derived signal features into one or more local event probabilities. This block is introduced to avoid direct expansion of all low-level signal descriptors into separate stochastic streams. Its role is especially important for signals with rich internal structure, such as acoustic, vibration, or optical time series.

Let ${\varphi }_i(t)$ be a feature vector extracted from physical channel $i$ over a time window centered at time $t$:

$${\varphi }_i(t)=[{\varphi }_{i.1}(t),{\varphi }_{i,2}(t),\dots ,{\varphi }_{i,m_i}(t)].$$

(2)

A direct stochastic mapping would encode each feature ${\varphi }_{i,j}(t)$ into a separate bitstream. This gives $m_i$​ bitstreams for a single physical channel. In contrast, the proposed hierarchical mapping forms a smaller number $k_i$​ of local event probabilities,

$$p_i(t)=[p_{i,1}(t),p_{i,2}(t),\dots ,p_{i,k_i}(t)],k_i\ll m_i,$$

(3)

where each $p_{i,l}(t)$ represents the relevance of the channel features to a specific local event descriptor. For an acoustic channel, these descriptors may correspond to a warning-like sound, acoustic disturbance, source confidence, or emergency-related sound activity. For a thermal channel, they may correspond to overheating, fast temperature rise, or abnormal thermal dynamics.

The mapping from ${\varphi }_i(t)$ to $p_i(t)$ may be implemented using rule-based functions, calibrated logistic mappings, fuzzy logic, Bayesian models, small classifiers, lookup tables, or other task-specific models. The important point is that the output must be interpretable as an event probability or, at minimum, as an event score that can be calibrated into a probability. Therefore, it is useful to distinguish between an event score $s_i(t)$ and an event probability $p_i(t)$. The score may be an arbitrary normalized detector output, while the probability should be calibrated so that its numerical value is meaningful for event-level processing.

A simple calibration relation can be expressed as

$$p_i(t)=\sigma ({\alpha }_i[s_i(t)-{\theta }_i]),$$

(4)

where $\sigma (\cdot )$ is a sigmoid function, ${\alpha }_i$​ controls the sharpness of the transition, and ${\theta }_i$​ is the event-score threshold. This formulation is not intended as the only possible calibration method. It is used here as a simple and transparent mapping for the numerical proof of principle.

2.2. Bernoulli Event-Bitstream Representation

After local event probabilities are formed, they are encoded into Bernoulli bitstreams. For a local event probability $p_i(t)$, a Bernoulli bitstream of length $N$ is defined as

$$B_i(t)=[b_{i,1}(t),b_{i,2}(t),\dots ,b_{i,N}(t)],$$

(5)

where

$$b_{i,n}(t)\sim Bernoulli(p_i(t)).$$

(6)

The probability estimate obtained from this bitstream is

$${\widehat{p}}_i(t)={\displaystyle \frac{1}{N}}{\displaystyle {\sum }_{n=1}^N}{b}_{i,n}(t).$$

(7)

Thus, the bitstream represents the local event probability statistically. Increasing $N$ reduces the sampling variance of the estimate, but also increases the processing latency, memory requirements, and synchronization burden. Therefore, bitstream length is a key design parameter of the proposed processor.

In the context of continuous monitoring, a separate bitstream is generated for each processing window. If the monitoring interval is divided into time windows of duration $\Delta t$, then the processor operates on a sequence of bitstream packets,

$$B_i\left[1\right],B_i\left[2\right],\dots ,B_i\left[K\right],$$

where $K$ is the number of time windows. This packet-based interpretation is useful for physical implementations because it explicitly separates the temporal monitoring scale from the bitstream length used within each window.

The bitstream representation also introduces an important source of uncertainty. Even if the local event probability $p_i(t)$ is known exactly, its stochastic estimate ${\widehat{p}}_i(t)$ fluctuates due to finite $N$. This finite-bitstream uncertainty is not a defect of the model; it is an intrinsic part of stochastic computing and must be quantified when evaluating the processor output.

2.3. Stochastic Event-Fusion Core

The stochastic event-fusion core combines local Bernoulli event streams into a global event-probability estimate. The specific fusion rule depends on the semantics of the target event. If the event may be triggered by any of several local indicators, an OR-like stochastic fusion can be used. If several conditions must be simultaneously satisfied, an AND-like confirmation can be used. If the local indicators have different relevance levels, a weighted fusion can be used. If one local event selects between processing branches, a multiplexer-based conditional operation can be applied.

For example, if two independent local event streams $B_a(t)$ and $B_b(t)$ encode probabilities $p_a(t)$ and $p_b(t)$, an AND operation estimates

$$p_{AND}(t)\approx p_a(t)p_b(t),$$

(8)

while an OR operation estimates

$$p_{OR}(t)\approx p_a(t)+p_b(t)-p_a(t)p_b(t).$$

(9)

A weighted event-fusion operation can be expressed at the probability level as

$$p_{fusion}\left(t\right)={\displaystyle {\sum }_{i=1}^M}{w}_i{p}_i\left(t\right),{\displaystyle {\sum }_{i=1}^M}{w}_i=1,$$

(10)

where $w_i$ are task-specific weights. In stochastic hardware, such a weighted operation may be approximated using multiplexer-based selection, stochastic averaging, or correlation-aware accumulation mechanisms.

The proposed architecture does not require a single universal fusion operation. Instead, it treats the stochastic event-fusion core as a configurable processing block. This is important because the meaning of a local event probability depends on the target application. For example, a warning-like acoustic event may be sufficient to increase a disturbance probability, while a fire-related event may require simultaneous support from smoke, thermal, and gas-related indicators. Therefore, fusion logic must be selected according to the physical and semantic structure of the monitored event.

2.4. Continuous Event-Probability Monitoring

A central feature of the proposed processor is that it operates cyclically over time. The output is not a single probability value but a time-resolved signal,

$$P_{event}\left[k\right],$$

where $k$ denotes the processing window. This output can be interpreted as the global event probability estimated by the stochastic fusion core for the $k$-th time window.

The temporal behavior of $P_{event}\left[k\right]$ is often more informative than its instantaneous value. A short isolated peak, repeated peaks, and a prolonged elevated probability may have different meanings even if they reach similar maximum levels. Therefore, the processor output is further analyzed using temporal metrics such as moving average, persistence above threshold, number of event episodes, accumulated exposure, and trend.

For example, a moving average can be written as

$${\overline{P}}_{event}\left[k\right]={\displaystyle \frac{1}{L}}{\displaystyle {\sum }_{r=0}^{L-1}}{P}_{event}[k-r],$$

(11)

where $L$ is the averaging window. Accumulated exposure is quantified in the numerical setup section.

These temporal descriptors allow the processor to distinguish between transient, repeated, and sustained event conditions. This is particularly important for monitoring applications where risk is not determined only by the instantaneous event probability, but also by duration, repetition rate, and temporal trend.

2.5. Direct Feature Mapping versus Hierarchical Event Mapping

The proposed hierarchy introduces a deliberate compression step. This compression is beneficial because it reduces the number of stochastic streams and simplifies the architecture. However, it may also introduce modeling error because multiple low-level features are replaced by fewer local event probabilities. Therefore, the proposed approach should be evaluated not only by output accuracy, but also by the trade-off between stream reduction, interpretability, and probability-estimation error.

In the direct mapping strategy, each feature is converted into a separate Bernoulli stream:

$${\varphi }_{i,j}(t)\to B_{i,j}(t).$$

(12)

If the channel has $m_i$​ features, it produces $m_i$​ streams. In the hierarchical event mapping strategy, the same features are first compressed into $k_i$ local event probabilities:

$${\varphi }_i(t)\to p_i(t)\to B_i(t),k_i\ll m_i.$$

(13)

This reduces the number of streams, but the output may deviate from the direct feature-level representation. In this work, the acoustic demonstration explicitly compares these two strategies to quantify the compression–accuracy trade-off.

The purpose of this comparison is not to show that hierarchical event mapping always produces lower numerical error. Rather, the purpose is to demonstrate that event-level representation can reduce the architectural burden while preserving the main event-related temporal structure. This distinction is important because the proposed processor is intended for event monitoring, where continuous interpretability and scalable stream management are as important as instantaneous reconstruction accuracy.

3. Acoustic Proof-of-Principle Model

The proposed architecture is demonstrated using a synthetic acoustic monitoring scenario. The acoustic channel is selected as an illustrative example because sound signals naturally contain multiple low-level descriptors, including amplitude, spectral structure, modulation, repetition, duration, and source-related characteristics. At the same time, many monitoring tasks do not require all of these descriptors as independent processor inputs. Instead, the relevant quantity is often the contribution of the acoustic channel to a target event, such as warning-like acoustic activity, acoustic disturbance, or emergency-related sound occurrence.

The goal of this proof-of-principle model is not to develop a complete acoustic event detection system. Such systems have been extensively studied in the literature, including acoustic scene classification, sound event detection, siren detection, emergency vehicle sound recognition, and urban sound monitoring [75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92]. Here, the acoustic signal is used to demonstrate the proposed processor pathway from low-level physical features to local event probabilities, then to Bernoulli event streams, and finally to a time-resolved global event-probability output.

The numerical experiment is based on synthetic acoustic-event scenarios. This allows full control of the event timeline, signal features, local probability mappings, and stochastic bitstream parameters. The model is therefore intended as an architecture-level proof of principle rather than as a benchmark on real-world acoustic datasets.

3.1. Time-Windowed Monitoring Scenario

The monitoring interval is divided into discrete time windows of duration $\Delta t$. In the numerical demonstration, a 30-minute monitoring sequence is used, with a processing window of 5 s. This gives $K=360$ processing windows. Each window is assigned one of the following scenario labels: background, isolated warning, repeated warning, vehicle/aircraft hum, impact-like, and prolonged warning.

The synthetic timeline contains both short and sustained events. The background scenario represents normal acoustic conditions. The isolated-warning scenario represents a short warning-like event. The repeated-warning scenario represents multiple warning-like patterns appearing over a longer interval. The vehicle/aircraft-hum scenario represents a lower-frequency sustained acoustic source. The impact-like scenario represents a short high-energy transient. The prolonged-warning scenario represents a sustained high-probability warning-like state.

This scenario design is intentionally simple. It is not intended to reproduce the full diversity of real urban acoustics. Instead, it provides controlled event types with different temporal structures, allowing the processor to be evaluated on isolated, repeated, transient, and prolonged acoustic events.

3.2. Acoustic Feature Representation

For each time window $k$, the acoustic channel is represented by a compact feature vector,

$${\varphi }_{audio}\left[k\right]=\left[{\varphi }_1\right[k],{\varphi }_2[k],\dots ,{\varphi }_m[k\left]\right].$$

In the proof-of-principle simulation, the features are normalized to the interval [0,1] and are designed to represent event-relevant acoustic descriptors rather than raw waveform samples. The model uses features such as:

$${\varphi }_{audio}\left[k\right]=\left[e\right[k],s[k],m[k],r[k],h[k],q[k\left]\right],$$

where e[k] denotes acoustic energy or intensity, s[k] denotes similarity to a warning-like reference pattern, m[k] denotes temporal modulation or periodicity, r[k] denotes repetition strength, h[k] denotes low-frequency hum content, and q[k] denotes impact-like transient strength.

These features are not treated as final stochastic processor inputs. Instead, they are used inside the local acoustic event-probability formation block. This is a central distinction of the proposed architecture. The processor does not directly require separate Bernoulli streams for all low-level acoustic descriptors. Rather, these descriptors are first mapped into event-level quantities.

3.3. Local Acoustic Event-Probability Formation

The acoustic proof-of-principle block used in this study is summarized in Figure 2.

The local acoustic block converts the feature vector ${\varphi }_{audio}\left[k\right]$ into a compact set of event probabilities. In the present demonstration, three local probabilities are formed: $p_{warning}(t),p_{disturbance}(t),p_{confidence}(t)$.

The first quantity, $p_{warning}(t)$, represents the probability that the acoustic window contains a warning-like event. It depends mainly on the similarity to reference warning patterns, temporal modulation, and repetition. The second quantity, $p_{disturbance}(t)$, represents the probability that the acoustic channel indicates a disturbance or abnormal acoustic activity. It may be influenced by warning-like patterns, impact-like events, and sustained low-frequency hum. The third quantity, $p_{confidence}(t)$, represents the confidence of the local acoustic interpretation. It is introduced to account for uncertainty in the local event-probability formation process.

The mapping can be written generally as

$$p_{audio}\left[k\right]=G_{audio}({\varphi }_{audio}[k]),$$

where

$$p_{audio}\left[k\right]=\left[p_{warning}\right[k],p_{disturbance}[k],p_{confidence}[k\left]\right].$$

The function $G_{audio}$​ is task-specific. In a real acoustic monitoring system, it could be implemented using a trained classifier, a reference-pattern matching algorithm, a Bayesian detector, a rule-based model, or a hybrid signal-processing and machine-learning pipeline. In the present proof-of-principle model, a transparent rule-based score followed by sigmoid calibration is used. This choice makes the numerical experiment reproducible and interpretable.

The event-score-to-probability mapping has the form

$$p\left[k\right]=\sigma (\alpha [s\left[k\right]-\theta ]),$$

where $s\left[k\right]$ is an intermediate event score, $\theta$ is a threshold, $\alpha$ is a slope parameter, and

$$\sigma (z)={\displaystyle \frac{1}{1+exp(-z)}}$$

is the sigmoid function. This calibration step distinguishes an arbitrary detector score from a probability-like event descriptor.

3.4. Reference Matching and Source-Level Interpretation

A key motivation for the acoustic example is that low-level acoustic parameters are not sufficient to define the event-level meaning of a sound. A warning signal may appear with different tones, intensities, durations, or recording conditions, yet still belong to the same semantic event class. Conversely, sounds with similar energy or dominant frequency may have different meanings depending on their source.

Therefore, the acoustic local block is conceptually organized around source-level and event-level interpretation. The first stage evaluates similarity to reference warning-like patterns. The second stage estimates whether the sound belongs to a disturbance or abnormal activity class. The third stage assigns a confidence level to the local acoustic interpretation.

In a practical system, reference matching could be performed using templates, spectral-temporal similarity measures, log-mel or MFCC-based descriptors, neural embeddings, or acoustic-event classifiers. The present model does not attempt to optimize this stage. Instead, it abstracts the reference-matching result as a normalized feature that contributes to $p_{warning}\left[k\right]$. This abstraction is sufficient for demonstrating how a local acoustic interpretation can be converted into a stochastic event stream.

3.5. Local Bernoulli Event Streams

After local event probabilities are obtained, each probability is encoded as a Bernoulli bitstream. For the acoustic block, the resulting streams are

$$B_{warning}\left[k\right],B_{disturbance}\left[k\right],B_{confidence}\left[k\right].$$

For a bitstream length $N$, each stream is defined as

$$B_x\left[k\right]=\left[b_{x,1}\right[k],b_{x,2}[k],\dots ,b_{x,N}[k\left]\right],$$

with

$$b_{x,n}\left[k\right]\sim Bernoulli(p_x[k]),$$

where $x$ denotes warning, disturbance, or confidence.

The stochastic estimate of the corresponding probability is

$${\widehat{p}}_x[k]={\displaystyle \frac{1}{N}}{\displaystyle \sum _{n=1}^N}{b}_{x,n}\left[k\right].$$

In the baseline simulation, $N=256$ is used as the main bitstream length. Additional values of $N$ are tested to evaluate sensitivity to bitstream length. This analysis is necessary because a shorter bitstream reduces computational latency and hardware burden, while a longer bitstream improves statistical accuracy.

3.6. Acoustic Event-Fusion Output

The local acoustic streams are combined to produce a global event-probability estimate for each time window. In the demonstration, the fusion operation is intentionally simple and interpretable. It combines warning-like evidence, disturbance evidence, and confidence information into a time-resolved event probability,

$$P_{event}\left[k\right].$$

At the probability level, the fusion can be represented generically as

$$P_{event}\left[k\right]=F(p_{warning}[k],p_{disturbance}[k],p_{confidence}[k]),$$

where $F(\cdot )$ is the selected event-fusion rule. At the stochastic level, the corresponding operation is performed on the Bernoulli streams,

$$B_{event}\left[k\right]=F(B_{warning}[k],B_{disturbance}[k],B_{confidence}[k]).$$

The output event probability is estimated as

$${\widehat{P}}_{event}\left[k\right]={\displaystyle \frac{1}{N}}{\displaystyle \sum _{n=1}^N}{b}_{event,n}\left[k\right].$$

This output is then analyzed over time. The central result of the demonstration is therefore not only whether an acoustic event is detected in a particular window, but how ${\widehat{P}}_{event}\left[k\right]$ evolves across the full monitoring interval.

3.7. Direct versus Hierarchical Acoustic Mapping

The acoustic example is also used to compare direct feature-to-bitstream mapping with the proposed hierarchical event-probability mapping.

In the direct approach, each acoustic feature is independently encoded as a stochastic stream:

$$e\left[k\right]\to B_e\left[k\right],s\left[k\right]\to B_s\left[k\right],m\left[k\right]\to B_m\left[k\right],r\left[k\right]\to B_r\left[k\right],h\left[k\right]\to B_h\left[k\right],q\left[k\right]\to B_q\left[k\right].$$

This gives six stochastic streams for the acoustic channel in the present model. In a more realistic acoustic system, the number of features could be much larger because spectral, temporal, cepstral, and neural-embedding descriptors may all be included.

In the hierarchical approach, these features are first mapped to three local event probabilities:

$$\left[e\right[k],s[k],m[k],r[k],h[k],q[k\left]\right]\to \left[p_{warning}\right[k],p_{disturbance}[k],p_{confidence}[k\left]\right].$$

Only these event-level probabilities are encoded as stochastic streams. Thus, in the present demonstration, the number of streams is reduced from six to three. This reduction is modest but sufficient to illustrate the architectural principle. In higher-dimensional physical channels, the same mechanism can provide a stronger reduction.

The comparison between the direct and hierarchical strategies is used to quantify the compression–accuracy trade-off. Direct mapping preserves more low-level information and may produce lower numerical error in certain cases. Hierarchical mapping reduces the number of streams and improves event-level interpretability, but may introduce additional modeling error due to feature compression. Both effects are evaluated in the numerical results.

4. Numerical Experiment Setup

The numerical experiment was designed as a reproducible architecture-level proof of principle. Its purpose is not to benchmark a real acoustic event detection system, but to demonstrate the complete processing pathway of the proposed hierarchical event-oriented stochastic processor. The simulation starts from a time-windowed acoustic scenario, generates normalized acoustic features, forms local event probabilities, converts them into Bernoulli bitstreams, performs stochastic event fusion, and finally analyzes the time-resolved output $P_{event}(t)$.

All calculations were implemented in a Python/Colab notebook. The notebook was structured to automatically generate the figures and tables used in the paper and supplementary material. Figures were exported at 600 dpi to ensure publication-quality resolution.

4.1. Monitoring Timeline and Scenario Labels

The simulated monitoring interval corresponds to 30 min of continuous observation. The signal is divided into processing windows of duration Δt=5 s. This gives K=360 time windows. The time axis is represented in minutes as

$$t_k={\displaystyle \frac{k\Delta t}{60}},k=\mathrm{0,1},\dots ,K-1.$$

Each processing window is assigned one acoustic scenario label. The baseline condition is background acoustic activity. Several event intervals are then inserted into the 30 min timeline to represent different temporal structures of acoustic events.

The simulated scenarios are summarized in Table 2.

This timeline allows the model to test several distinct temporal behaviors: isolated events, repeated events, prolonged events, sustained non-warning acoustic activity, and short impulsive disturbances.

4.2. Synthetic Acoustic Feature Generation

For each time window, a normalized acoustic feature vector is generated:

$${\varphi }_{audio}\left[k\right]=\left[e\right[k],s[k],m[k],r[k],h[k],q[k\left]\right],$$

where: e[k] is the acoustic energy or intensity feature; s[k] is similarity to a warning-like acoustic pattern; m[k] is temporal modulation or periodicity; r[k] is repetition strength; h[k] is low-frequency hum content; q[k] is impact-like transient strength.

All features are normalized to the interval [0,1]. The feature values are generated synthetically according to the assigned scenario label. Background windows have low event-related features. Warning-like scenarios have high warning similarity, modulation, and repetition features. Vehicle- or aircraft-like hum has increased low-frequency hum and moderate disturbance-related features. Impact-like events have high transient strength but limited persistence.

The synthetic generation approach was selected to provide full control over the event structure and to make the numerical demonstration transparent and reproducible. The model is therefore not intended to replace real acoustic feature extraction from waveform or spectrogram data.

4.3. Local Event-Probability Formation

The synthetic acoustic features are converted into three local event probabilities:

$$p_{warning}\left[k\right],p_{disturbance}\left[k\right],p_{confidence}\left[k\right].$$

The warning probability represents the local probability of a warning-like acoustic event. It is mainly controlled by warning similarity, temporal modulation, and repetition. The disturbance probability represents the local probability of an acoustically relevant disturbance and is influenced by warning-like activity, impact-like events, and sustained hum. The confidence probability represents the reliability of the local interpretation of the acoustic signal.

Intermediate event scores are first formed from weighted combinations of acoustic features. These scores are then converted into probability-like outputs using a sigmoid calibration function,

$$p[k]={\displaystyle \frac{1}{1+exp[-\alpha (s\left[k\right]-\theta )]}},$$

where $s\left[k\right]$ is the event score, $\theta$ is the threshold parameter, and $\alpha$ controls the slope of the score-to-probability transition.

This calibration step is included to emphasize the distinction between arbitrary feature scores and event probabilities. In this proof-of-principle model, the calibration is rule-based and synthetic. In a real application, it could be replaced by empirical calibration, logistic regression, Bayesian calibration, isotonic regression, or a trained classifier output calibration.

4.4. Bernoulli Bitstream Generation

Each local event probability is represented by a Bernoulli bitstream. For a probability $p_x\left[k\right]$, where $x$ denotes warning, disturbance, or confidence, a bitstream of length $N$ is generated as

$$B_x\left[k\right]=\left[b_{x,1}\right[k],b_{x,2}[k],\dots ,b_{x,N}[k\left]\right],$$

with

$$b_{x,n}\left[k\right]\sim Bernoulli(p_x[k]).$$

The corresponding stochastic estimate is

$${\widehat{p}}_x\left[k\right]={\displaystyle \frac{1}{N}}{\displaystyle \sum _{n=1}^N}{b}_{x,n}\left[k\right].$$

The baseline simulation uses $N=256$.

To evaluate the effect of bitstream length on statistical error, additional values were tested:

$$N\in \left\{\mathrm{32,64,128,256,512,1024}\right\}.$$

This analysis is important because bitstream length directly affects the trade-off between statistical accuracy and processing cost. Shorter bitstreams reduce latency and hardware burden but increase stochastic sampling error. Longer bitstreams improve probability estimation but require more processing time and synchronization.

For a stochastic fusion operation to be meaningful, all event streams entering the fusion core must refer to the same processing window and must be represented by compatible bitstream packets. Therefore, the architecture assumes a preparation and time-synchronization stage that aligns local event probabilities by timestamp, buffers delayed channels, and generates bitstreams of a common length N for each window. Without this alignment, stochastic logic operations could combine event evidence originating from different physical time intervals, leading to incorrect event interpretation.

4.5. Stochastic Event-Fusion Rules

The local Bernoulli event streams are processed by a stochastic event-fusion core. The proof-of-principle model includes several simple fusion operations designed to illustrate different semantic roles of local event probabilities.

First, an AND-like confirmation operation combines warning-like evidence with confidence:

$$B_{confirm}\left[k\right]=B_{warning}\left[k\right]\wedge B_{confidence}\left[k\right].$$

At the probability level, assuming statistical independence, this approximates

$$p_{confirm}\left[k\right]\approx p_{warning}\left[k\right]pconfidence\left[k\right].$$

Second, an OR-like accumulation operation combines warning-related and disturbance-related evidence:

$$B_{or}\left[k\right]=B_{warning}\left[k\right]\vee B_{disturbance}\left[k\right].$$

At the probability level, for independent streams, this approximates

$$p_{or}\left[k\right]\approx p_{warning}\left[k\right]+p_{disturbance}\left[k\right]-p_{warning}\left[k\right]p_{disturbance}\left[k\right].$$

Third, a weighted fusion output is calculated to obtain the final time-resolved event probability. In the numerical demonstration, the global event probability is formed as a weighted combination of local event estimates and stochastic fusion outputs. This represents a configurable event-fusion rule rather than a universal formula.

The resulting processor output is denoted as $P_{event}\left[k\right]$.

This value is computed for each time window, producing a time-resolved event-probability signal.

4.6. Temporal Analysis Metrics

The output $P_{event}\left[k\right]$ is analyzed as a continuous monitoring signal. Several temporal metrics are calculated.

The moving average is computed as

$${\overline{P}}_{event}\left[k\right]={\displaystyle \frac{1}{L}}{\displaystyle \sum _{r=0}^{L-1}}{P}_{event}[k-r],$$

where $L$ is the number of windows in the averaging interval. In the baseline analysis, a 1 min moving average is used.

Persistence above threshold is calculated as the total duration for which the event probability exceeds a selected threshold:

$$T_{persist}=\Delta t{\displaystyle \sum _{k=1}^K}I\left[P_{event}\right[k]>\gamma ],$$

(14)

where $\gamma$ is the event threshold and $I[\cdot ]$ is the indicator function.

Accumulated exposure is defined as

$$E_{event}={\displaystyle \sum _{k=1}^K}{P}_{event}\left[k\right]\Delta t.$$

(15)

This quantity reflects the cumulative event load over the monitoring interval. It is useful for distinguishing a single short peak from repeated or prolonged elevated event probability.

The number of event episodes is estimated by counting contiguous intervals in which $P_{event}\left[k\right]$ exceeds the event threshold. This metric differentiates isolated events from repeated event activity.

4.7. Direct Feature-to-Bitstream Mapping Baseline

To evaluate the benefit and cost of hierarchical event mapping, a direct feature-to-bitstream baseline is included. In the direct approach, each acoustic feature is independently converted into a Bernoulli bitstream:

$$e\left[k\right]\to B_e\left[k\right],s\left[k\right]\to B_s\left[k\right],m\left[k\right]\to B_m\left[k\right],r\left[k\right]\to B_r\left[k\right],h\left[k\right]\to B_h\left[k\right],q\left[k\right]\to B_q\left[k\right].$$

Thus, the direct acoustic representation uses six bitstreams in the present model. In contrast, the hierarchical representation uses three event-level bitstreams:

$$B_{warning}\left[k\right],B_{disturbance}\left[k\right],B_{confidence}\left[k\right].$$

The stream reduction factor is therefore

$$R={\displaystyle \frac{N_{direct}}{N_{hierarchical}}}={\displaystyle \frac{6}{3}}=2.$$

(16)

Although this reduction is moderate in the present simplified acoustic example, it demonstrates the architectural mechanism. In realistic acoustic monitoring systems, the number of low-level features can be much larger, making event-level compression more significant.

The direct and hierarchical strategies are compared using probability-estimation error and stream count. The comparison is not intended to prove that hierarchical mapping is always more accurate. Rather, it evaluates whether the hierarchical strategy can reduce the number of stochastic streams while preserving the main temporal event structure.

4.8. Evaluation Metrics and Outputs

The following metrics are computed in the numerical experiment:

• Mean event probability by scenario. The average value of $P_{event}\left[k\right]$ is computed for each scenario label.
• Local bitstream reconstruction error. The RMSE between each local probability $p_x\left[k\right]$ and its stochastic estimate ${\widehat{p}}_x\left[k\right]$ is calculated.
• Bitstream-length sensitivity. The effect of $N$ on stochastic estimation error is evaluated for $N=\mathrm{32,64,128,256,512,1024}.$
• Temporal monitoring metrics. Persistence above threshold, number of event episodes, moving average, and accumulated exposure are computed from $P_{event}\left[k\right]$.
• Direct versus hierarchical mapping error. The direct feature-to-bitstream mapping and the hierarchical event-probability mapping are compared in terms of stream count and RMSE.

The simulation automatically generates publication-quality figures and tables. The main outputs include: synthetic acoustic feature timelines; local event-probability curves; Bernoulli bitstream reconstruction plots; stochastic event-fusion output; time-resolved $P_{event}\left[k\right]$; temporal monitoring metrics; direct versus hierarchical mapping comparison; bitstream-length sensitivity plots and tables. These outputs provide the basis for the numerical results presented in the next section.

5. Results

The numerical experiment demonstrates the complete processing pathway of the proposed hierarchical event-oriented stochastic processor. The results are presented in six steps: generation of acoustic-event scenarios, formation of local event probabilities, Bernoulli bitstream reconstruction, stochastic event fusion, temporal event-probability monitoring, and comparison between direct and hierarchical stochastic mappings.

5.1. Synthetic Acoustic Scenarios and Feature-Level Response

The 30 min monitoring sequence contains background activity and five inserted acoustic-event scenarios: isolated warning, repeated warning, vehicle- or aircraft-like hum, impact-like disturbance, and prolonged warning. These scenarios were selected to represent different temporal event structures rather than to reproduce real acoustic recordings. The purpose was to test whether the proposed processor can distinguish transient, repeated, sustained, and non-warning acoustic activity at the event-probability level.

The generated feature trajectories for the synthetic acoustic monitoring sequence are shown in Figure 3.

The generated feature trajectories show that the warning-like scenarios produce high values of warning similarity, temporal modulation, and repetition-related features. The vehicle- or aircraft-like scenario mainly increases the low-frequency hum descriptor, while the impact-like scenario produces a short increase in the transient-impact feature. Background intervals remain at low event-related feature levels. Thus, the synthetic features provide a controlled input for evaluating local event-probability formation.

This feature-level behavior confirms that the scenario generator produces distinguishable acoustic patterns suitable for testing the proposed architecture. However, the features themselves are not used as final processor-level inputs in the hierarchical approach. Instead, they are converted into local event probabilities.

5.2. Local Acoustic Event Probabilities

The local acoustic block converts the six normalized acoustic features into three event-level probabilities: $p_{warning}(t),p_{disturbance}(t),p_{confidence}(t)$.

The warning probability increases strongly during isolated, repeated, and prolonged warning-like intervals. The disturbance probability responds not only to warning-like acoustic patterns but also to impact-like and sustained hum-like conditions. The confidence probability remains higher when the local acoustic interpretation is consistent and lower when the feature combination is less specific.

This confirms the intended role of the local event-probability formation block: it compresses several low-level acoustic descriptors into a compact set of event-level quantities. Instead of sending all acoustic features directly to the stochastic fusion core, the processor receives local event probabilities that already carry task-relevant semantic meaning.

The resulting local acoustic event probabilities are presented in Figure 4.

The resulting local probabilities are therefore better suited for event-oriented stochastic processing than raw feature streams. They represent not merely “frequency,” “energy,” or “modulation,” but event-level acoustic evidence.

5.3. Bernoulli Bitstream Reconstruction Accuracy

Each local event probability was encoded as a Bernoulli bitstream. The baseline bitstream length was $N=256$.

The stochastic estimate of each probability was obtained as the fraction of ones in the generated bitstream. The RMSE between the ideal local probability and the stochastic estimate was calculated for each local event stream.

Examples of Bernoulli event-bitstream realizations are shown in Figure 5.

Table 3. Local Bernoulli bitstream reconstruction error for $N=256.$

Local probability	RMSE
pwarning(t)	0.0185
pdisturbance(t)	0.0262
pconfidence(t)	0.0248

Table 3. Local Bernoulli bitstream reconstruction error for $N=256.$

Local probability	RMSE
pwarning(t)	0.0185
pdisturbance(t)	0.0262
pconfidence(t)	0.0248

The reconstruction errors are small for the baseline stream length, indicating that $N=256$ provides a sufficiently stable stochastic representation for the proof-of-principle demonstration. As expected for Bernoulli sampling, the stochastic estimate fluctuates around the ideal probability, and the magnitude of the fluctuation depends on bitstream length and probability value.

These results confirm that the local event probabilities can be represented by finite Bernoulli bitstreams with controlled statistical error. This is important because the subsequent event-fusion core operates on stochastic streams rather than directly on floating-point probabilities.

5.4. Stochastic Event Fusion and Time-Resolved Output

The local event streams were combined by the stochastic event-fusion core. The resulting output is a time-resolved global event-probability signal,

$$P_{event}(t).$$

The mean values of $P_{event}(t)$​ computed for each scenario are summarized in Table 4.

The background scenario produces a low mean event probability. Warning-like scenarios produce high values, with repeated and prolonged warning intervals reaching mean probabilities above 0.90. The isolated warning scenario also produces a high mean value, but only over a short interval. The vehicle- or aircraft-like hum and impact-like scenarios produce intermediate values, reflecting their disturbance-related but less warning-specific character.

The stochastic fusion output and the resulting time-resolved event probability $P_{event}\left(t\right)$ are shown in Figure 6.

These results show that the processor output is sensitive to the event-level meaning of the acoustic pattern. It does not simply respond to any acoustic activity as a high-probability event. Instead, warning-like repeated and prolonged patterns produce stronger event probabilities than background, hum-like, or impact-like scenarios.

5.5. Temporal Event-Probability Monitoring

A central goal of the proposed architecture is continuous monitoring rather than one-time classification. Therefore, the most important output is the full time series $P_{event}(t)$, not only the mean value for each scenario.

The time-resolved output shows low event probability during background intervals, a short peak during the isolated-warning event, repeated high-probability intervals during repeated-warning activity, a moderate response during the vehicle- or aircraft-like hum interval, a short transient response during the impact-like interval, and sustained high probability during the prolonged-warning interval.

Temporal analysis of the time-resolved event-probability signal is presented in Figure 7.

Temporal analysis was performed using a threshold-based persistence metric, moving average, accumulated exposure, and event-episode counting. The baseline temporal metrics are summarized in Table 5.

The persistence above threshold indicates that the processor output remains in an elevated event-probability state for a total of 9.42 min during the 30 min monitoring sequence. The number of event episodes equals 3, corresponding to temporally separated high-probability event regions. The accumulated exposure value reflects the integrated event-probability load over the full monitoring interval.

These temporal metrics demonstrate why continuous monitoring is important. A short isolated warning, repeated warnings, and prolonged warning activity may all produce high instantaneous event probabilities, but their temporal signatures are different. The proposed processor therefore supports not only event detection but also event-state interpretation over time.

The accumulated event exposure derived from $P_{event}(t)$ is shown in Figure 8.

5.6. Direct Feature-to-Bitstream Mapping versus Hierarchical Event Mapping

The direct feature-to-bitstream baseline encodes each of the six acoustic features as an independent stochastic stream. The hierarchical mapping compresses these features into three local event probabilities and then encodes only those event probabilities as Bernoulli streams. Thus, in the present demonstration, the number of streams is reduced from six to three: $R=6/3=2$.

The stream-count reduction achieved by hierarchical event mapping is illustrated in Figure 9.

To evaluate the effect of this compression, the direct and hierarchical mappings were compared over several bitstream lengths. The resulting RMSE values are shown in Table 6.

The direct mapping produces lower RMSE for all tested bitstream lengths. This is expected because direct mapping preserves more feature-level information and avoids the additional modeling error introduced by event-level compression. In contrast, the hierarchical mapping reduces the number of streams but introduces a compression error associated with mapping several low-level features into fewer local event probabilities.

This result is important because it shows that hierarchical event mapping should not be interpreted as a universally more accurate numerical representation. Its advantage is architectural rather than purely numerical: it reduces the number of stochastic streams, improves event-level interpretability, and makes the processor more scalable for continuous monitoring.

Thus, the proposed architecture introduces a compression–accuracy trade-off. Direct mapping may be preferable when preserving all feature-level details is critical and the number of streams is manageable. Hierarchical event mapping becomes more attractive when the number of physical features is large, when synchronization and hardware complexity are limiting factors, or when event-level interpretation is more important than exact feature-level reconstruction.

5.7. Effect of Bitstream Length

The results also confirm the expected influence of bitstream length. In the direct mapping case, the RMSE decreases as the bitstream length increases from $N=32$ to $N=1024$. This reflects the reduction of Bernoulli sampling error with longer streams.

For the hierarchical mapping, the RMSE decreases only slightly and remains around 0.09. This indicates that, in the current model, the hierarchical error is dominated not by Bernoulli sampling noise but by the event-level compression model. Increasing the bitstream length cannot remove this modeling error. This distinction is important for processor design: once stochastic sampling error becomes sufficiently small, further improvements require better event-probability formation rather than longer bitstreams.

The effect of bitstream length on the direct and hierarchical mappings is summarized in Figure 10.

Therefore, the bitstream-length analysis separates two sources of error:

• Stochastic sampling error, which decreases with increasing $N$;
• Event-compression error, which depends on the local event-probability formation model.

This distinction should be considered when optimizing future implementations.

5.8. Summary of Numerical Findings

The numerical proof of principle supports the main architectural claims of the proposed processor.

First, the acoustic local block successfully converts low-level features into compact local event probabilities. This demonstrates the feasibility of replacing direct feature-level stochastic encoding with event-level encoding.

Second, Bernoulli bitstreams of length $N=256$ reproduce the local event probabilities with low reconstruction error. This confirms that local event probabilities can be represented in stochastic form with controlled statistical fluctuations.

Third, stochastic event fusion produces a time-resolved global probability signal $P_{event}(t)$. This output distinguishes background, isolated warning, repeated warning, prolonged warning, hum-like, and impact-like acoustic scenarios.

Fourth, temporal metrics such as persistence, number of event episodes, moving average, and accumulated exposure provide information that is not available from a single static probability value. This supports the idea that the processor should be interpreted as a continuous monitoring system.

Fifth, the direct versus hierarchical comparison demonstrates a clear compression–accuracy trade-off. Hierarchical event mapping reduces the number of bitstreams from six to three in the present example, but produces higher RMSE than direct feature mapping. This result is consistent with the intended role of the hierarchy: it improves architectural compactness and event-level interpretability, not necessarily raw numerical reconstruction accuracy.

Overall, the results validate the proposed architecture as an event-oriented stochastic processing framework. The acoustic demonstration shows how physical signal features can be converted into local event probabilities, encoded as Bernoulli streams, stochastically fused, and analyzed as a time-resolved event-probability output.

6. Discussion

The numerical proof of principle demonstrates the feasibility of representing event-oriented physical information as compact Bernoulli event streams and processing these streams in a continuous stochastic monitoring architecture. The results should be interpreted at the architectural level rather than as a benchmark of acoustic event detection accuracy. The main contribution is the proposed processing principle: local event-probability formation, stochastic event fusion, and time-resolved global event-probability monitoring.

6.1. Interpretation of the Hierarchical Event-Probability Approach

The proposed architecture changes the role of low-level physical features in stochastic processing. In a direct feature-to-bitstream approach, each signal descriptor is treated as a separate stochastic input. This is straightforward, but it scales poorly when the number of descriptors grows. Acoustic signals provide a clear example: amplitude, dominant frequency, spectral structure, modulation, repetition, duration, transient strength, and source-class indicators can all be useful, but encoding each as a separate Bernoulli stream would rapidly increase stream count and synchronization complexity.

The hierarchical approach addresses this issue by introducing local event-probability formation blocks. These blocks do not discard the low-level features; instead, they use them internally to estimate event-level descriptors. In the acoustic example, the feature vector is compressed into warning, disturbance, and confidence probabilities. These probabilities are more directly aligned with the target monitoring task than the original low-level features.

Therefore, the architecture does not simply perform dimensionality reduction. It performs event-oriented abstraction. The output of the local block is not an arbitrary compressed feature vector but a compact probabilistic representation of event relevance. This makes the subsequent stochastic processing stage more interpretable, because the stochastic streams represent event-level quantities rather than raw physical descriptors.

6.2. Compression–Accuracy Trade-Off

The direct versus hierarchical comparison shows that the hierarchical representation introduces a compression–accuracy trade-off. In the present demonstration, direct feature-to-bitstream mapping gives lower RMSE than hierarchical mapping for all tested bitstream lengths. This result is expected because direct mapping preserves the original feature-level information, whereas hierarchical mapping compresses six acoustic features into three event probabilities.

This observation is important for the correct interpretation of the proposed architecture. The hierarchical approach should not be presented as a universal method for reducing numerical error. Its primary advantage is architectural compactness and semantic interpretability. By reducing the number of streams, the architecture reduces the burden on stream generation, synchronization, routing, and stochastic fusion. These factors are especially important for optical, photonic, or hybrid implementations where each additional stream may correspond to an additional physical channel, optical path, detector, modulator, or processing element.

The results also show that increasing bitstream length does not remove the main error source in the hierarchical case. For the direct mapping, RMSE decreases with increasing $N$ , indicating that Bernoulli sampling noise is a dominant contribution. For the hierarchical mapping, RMSE remains close to 0.09 even for longer streams, indicating that the error is mainly caused by event-level compression. This separation is useful for future design: bitstream length should be increased only until stochastic sampling error becomes acceptable; further improvement then requires better local event-probability formation rather than longer streams.

6.3. Importance of Continuous Monitoring

A key aspect of the proposed processor is that its output is a time-resolved probability signal, $P_{event}(t)$, rather than a single static decision. This is essential for event-oriented monitoring tasks. A short isolated event, repeated events, and a prolonged high-probability state can all produce high instantaneous probability values, but they have different temporal meanings.

The numerical results illustrate this distinction. The isolated warning scenario produces a short high-probability response. The repeated-warning scenario produces multiple elevated intervals. The prolonged-warning scenario produces a sustained high-probability state. These cases are not equivalent from the point of view of monitoring, risk assessment, or decision support. Temporal descriptors such as persistence above threshold, accumulated exposure, and event-episode count provide information that cannot be captured by a single probability value.

This continuous-processing interpretation also strengthens the stochastic nature of the proposed architecture. The processor is not merely a one-time classifier followed by stochastic encoding. Instead, it repeatedly forms local event probabilities, generates Bernoulli event streams, fuses them, and updates $P_{event}(t)$ over time. The object of computation is therefore a stochastic event-probability process.

6.4. Relation to Optical and Photonic Stochastic Processors

The present work is formulated at the architecture and numerical proof-of-principle level. Nevertheless, it is motivated by optical and photonic stochastic computing. Existing optical SC and probabilistic photonic works demonstrate that stochastic logic, optical random sources, photonic probabilistic bits, stochastic neural components, and optical accelerators are physically plausible building blocks for future processors [21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40]. Optical logic gates and photonic combinational circuits also provide a basis for implementing higher-level processing blocks [41,42,43,44,45,46,47,48,49,50,51,52,53,54].

The proposed architecture can be interpreted as a processor-level framework that could organize such building blocks for event-oriented monitoring. Local event probabilities may initially be formed in digital, electronic, or optoelectronic subsystems. These probabilities can then be encoded into optical or photonic stochastic streams for fusion. Alternatively, in a more advanced implementation, some local event-probability formation and fusion functions could themselves be implemented optically or photonically.

For a bulk-optics demonstrator, the architecture is also useful because it separates the conceptual processor levels. Local event probabilities can be generated electronically or computationally, while the stochastic fusion core can be demonstrated using optical logic modules. This hybrid pathway is realistic for early experimental validation. A fully integrated photonic implementation would require additional development of compact random-bit generation, optical stream synchronization, correlation control, and scalable routing.

Thus, the proposed architecture should not be interpreted as a claim that all processing stages must already be fully optical. Rather, it defines a hierarchical processing framework that is compatible with electronic, optical, photonic, and hybrid implementations.

6.5. Local Event Blocks versus External Frontend

A possible criticism is that the local event-probability formation block may appear to be an external intelligent frontend rather than part of the stochastic processor. In this work, the local blocks are treated as the first computational level of the processor architecture. Their purpose is to transform physical-channel features into local event probabilities that can be processed stochastically.

This distinction is important. If the local block produced a final decision, the stochastic processor would indeed become unnecessary. However, in the proposed architecture, local blocks do not determine the final global event state. They produce intermediate event-probability streams. The final output is obtained only after stochastic fusion and temporal analysis.

For example, an acoustic block may estimate $p_{warning}(t)$, $p_{disturbance}(t)$ and $p_{confidence}(t)$. These quantities may be useful, but they are not yet the final target event probability. In a multisensor version of the processor, they would be fused with thermal, optical, vibration, gas, or contextual event streams. Therefore, local event-probability formation is not a replacement for the stochastic processor; it is the first level of its hierarchy.

6.6. Limitations of the Current Proof-of-Principle Model

The present study has several limitations. First, the acoustic scenario is synthetic. The generated features are designed to represent idealized warning-like, disturbance-like, hum-like, impact-like, and background patterns. The model does not yet use real acoustic recordings, measured urban soundscapes, or benchmark datasets. Second, the local event-probability formation model is rule-based. It uses transparent feature combinations and sigmoid calibration for interpretability. In practical applications, this block would need to be trained, calibrated, and validated on real data.

Third, only one physical channel is modeled in detail. The architecture is intended to support multiple physical channels, but the present preprint demonstrates the concept using the acoustic channel only. Multisensor demonstrations involving thermal, optical/smoke, vibration, gas, or context channels are left for future work. Fourth, the stochastic fusion rules are simple. The proof of principle uses interpretable AND-like, OR-like, and weighted fusion operations. More complex event-fusion logic could include adaptive weights, correlation-aware fusion, Bayesian fusion, stochastic finite-state machines, or learned stochastic decision structures. Fifth, correlation between streams is not fully explored. In stochastic computing, correlation may be harmful or beneficial depending on the operation. The present model uses the standard Bernoulli-stream assumption for the baseline demonstration. Future work should explicitly analyze correlation control, decorrelation, and intentional correlation in event-fusion operations. Sixth, the model does not claim hardware superiority over digital processing. The numerical demonstration is not an energy or latency benchmark. Its purpose is to establish the architectural concept and show the processing pathway from physical features to time-resolved stochastic event probability.

6.7. Future Extensions

The next step is to extend the proof of principle from a single acoustic channel to a multisensor event-oriented processor. In such a model, each physical channel would have its own local event-probability formation block. For example:

$$p_{audio}(t),p_{thermal}(t),p_{optical}(t),p_{vibration}(t),p_{context}(t)$$

could be encoded as Bernoulli event streams and fused into a global event probability.

Another important direction is to test the architecture on real or semi-real data. For the acoustic case, this could involve urban sound datasets, siren-detection datasets, or controlled recordings. For optical or environmental monitoring, measured smoke-transmittance, thermal, vibration, or gas-sensor data could be used.

The architecture should also be evaluated under degraded conditions, including missing channels, stale data, asynchronous sampling, noisy features, and conflicting local event probabilities. These conditions are important for continuous monitoring systems and would make the event-oriented stochastic processor more realistic.

Finally, future work should examine hardware implementation pathways. The proposed architecture can support digital, electronic, bulk-optics, integrated photonic, and hybrid realizations. Early experimental work may use bulk-optical stochastic logic modules for fusion while retaining digital local event-probability formation. Later implementations may replace more of the hierarchy with optical or photonic processing blocks.

6.8. Implications for Event-Oriented Stochastic Processing

The proposed architecture suggests that stochastic computing can be extended beyond isolated arithmetic blocks and neural-network accelerators toward continuous event-probability monitoring. This requires a shift from feature-level stochastic representation to event-level stochastic representation.

The main implication is that stochastic processors should not necessarily receive all physical features as independent streams. Instead, local event-probability formation can reduce the stream count and provide more meaningful processor inputs. The stochastic processor then operates on event probabilities rather than raw physical descriptors.

This interpretation is especially relevant for sensing systems, where uncertainty, noise, incomplete data, and time-dependent event evolution are natural. In such systems, the goal is often not to compute a precise deterministic value, but to continuously update the probability of a target event and support decisions based on its temporal behavior.

7. Conclusion

This work proposed a hierarchical event-oriented stochastic processor architecture for continuous monitoring of event probabilities. The main motivation was the scalability limitation of direct feature-to-bitstream mapping. When physical signals are decomposed into many low-level descriptors, direct encoding of each descriptor as an independent Bernoulli bitstream rapidly increases the number of streams, synchronization paths, stochastic processing blocks, and physical channels required for implementation.

The proposed architecture addresses this problem by introducing local event-probability formation blocks. These blocks convert task-relevant physical features into compact local event probabilities before stochastic encoding. The local probabilities are then represented as Bernoulli bitstreams and processed by a stochastic event-fusion core. The processor output is not a single static value, but a time-resolved global event-probability signal, $P_{event}(t)$, which enables continuous monitoring of event persistence, repetition, temporal trend, and accumulated exposure.

A synthetic acoustic monitoring scenario was used as an architecture-level proof of principle. The acoustic example demonstrated the full processing pathway from low-level acoustic descriptors to local event probabilities, Bernoulli event streams, stochastic fusion, and time-resolved event-probability monitoring. The results showed that warning-like acoustic patterns produced high event probabilities, background intervals remained at low probability levels, and transient, repeated, and prolonged events could be distinguished through temporal analysis of $P_{event}(t)$.

The numerical results also demonstrated a clear compression–accuracy trade-off. Direct feature-to-bitstream mapping provided lower RMSE because it preserved more feature-level information. In contrast, hierarchical event mapping reduced the number of stochastic streams and improved event-level interpretability, but introduced additional compression error. This result supports the main architectural interpretation of the proposed approach: hierarchical event mapping should not be viewed as a universal accuracy-improvement method, but as a strategy for scalable, interpretable, event-level stochastic processing.

The proposed framework is compatible with digital, electronic, optical, photonic, and hybrid implementations. In early experimental systems, local event probabilities may be formed digitally or electronically, while stochastic fusion can be implemented using electronic, bulk-optical, or photonic logic modules. In future integrated implementations, a larger part of the hierarchy may be realized using optical or photonic stochastic computing elements.

Future work should extend the present acoustic proof of principle to multisensor scenarios involving thermal, optical, vibration, gas, and contextual channels. Further studies should also include real or semi-real datasets, calibrated local event-probability formation, explicit stream-correlation analysis, asynchronous sampling, missing or stale data, and experimental validation of optical or hybrid stochastic fusion modules. These extensions would allow the proposed architecture to evolve from a conceptual and numerical proof of principle toward a practical event-oriented stochastic processing platform for probabilistic sensing and decision-support systems.