DEV Community: miosync-masa

Lambda : The New Era of Structural, Event-Driven Bayesian Time Series Analytics

miosync-masa — Mon, 30 Jun 2025 02:33:52 +0000

Discover the most advanced open-source implementation of Lambda³ theory — a framework that shatters classical time-series analysis. Go beyond curve-fitting: track structural pulses, regime shifts, and emergent networks at the most granular level.

🚀 Concept

Classical Bayesian and VAR models are great... until reality hits:

markets, climate, biology—all full of jumps, switches, surprises.

Lambda³ (Λ³) separates the “smooth trend” from explicit “jump (event)” states—so you can track not just when and where something changes, but why (structurally) and how confidently.

No more curve-fitting tyranny.
Events are first-class citizens.
Everything’s human-interpretable.

"Why is my Bayesian fit so blind to regime changes?"

"I wish I could just see what caused that spike..."

What is a "jump-event"?

A jump-event is an abrupt, discrete structural change in a time series — a sudden “jump” rather than a slow drift or regular fluctuation. Unlike classical change-point detection, which finds broader regime shifts, or outlier detection, which flags rare extreme values, a jump-event specifically marks a moment where the underlying process rapidly changes state (for example: price shock, heart rhythm flip, regime switch).

Jump-events capture both the direction (positive/negative) and magnitude of these structural pulses, enabling you to analyze how, when, and why critical transitions occur — not just whether the mean or variance has shifted.

In Lambda³, jump-events are treated as first-class structural events — the core “particles” of change, not just noise or anomalies.

Method	What it detects	Typical Output	Example Use Case	Limitation	Lambda³ Usage
Jump-event detection	Abrupt, local, signed structural changes	List of jump events (location, sign, magnitude)	Causal impact, shock propagation, structural analysis	May be “hidden” if only looking at means/variance	Core primitive (“event-pulse”)
Change-point detection	Broad regime shifts or statistical changes (mean/variance/trend)	Change-point indices (segment boundaries)	Regime segmentation, volatility regime, drift	Misses small, rapid events; only coarse boundaries	Used for regime annotation
Outlier detection	Rare, extreme values (anomalies, noise, errors)	Outlier indices/flags	Data cleaning, anomaly detection	Not always meaningful for structure; may mix noise & real jumps	Used for data QC (not structural)

Tip:

Jump-events = Local, structural "pulses" that drive system evolution.

Change-points = Big regime shifts (segments, plateaus).

Outliers = Rare anomalies, usually noise or data error.

Lambda³ makes jump-events the main unit of analysis: they are not “noise”—they ARE the change.

Welcome to the new standard.

Cross-Series Interaction (Causal impact coefficients β)	Synchronization Matrix (Pairwise event sync rate σₛ)	Network Structure (Event-driven directed sync graph)
Interaction effects: Causal structure between series (columns: source, rows: target)	Synchronization matrix: Event-based σₛ for all pairs (higher = more synchronous)	Network graph: Directed info flow & optimal lag structure (arrows show direction)

Series Fit + Events (Model fit & jump detection)	Posterior Parameter Estimates (Bayesian 94% HDI)
Model fit: Original data, prediction, detected jumps (colored), local events	Posterior distributions: Key coefficients with 94% highest density interval (HDI)

🌟 Key Innovations in Lambda³ Computational Framework

1. Complete Structural Tensor (Λ) Representation

Automatic jump-event (ΔΛC±) detection: Identify both positive and negative structural “pulses” independently, not just mean/variance changes.
JIT-accelerated: Lightning-fast computation on large datasets via Numba/JAX.
No dependence on time: Changes are detected by structural thresholds, not timestamps.

2. Dynamic Tension Scalar (ρT)

# Continuously quantifies local structural tension
rho_t = calculate_rho_t(data, window)

Each point’s “stress” is measured structurally, not temporally.
Variability is modeled as a function of structure, not time—a paradigm shift.

3. Multidimensional Synchronization (σₛ) Analysis

Automatic pairwise event synchronization matrix.
Optimal lag & causal direction detection.
Tracks dynamic synchronization rate evolution over time or transactions.

4. Bayesian Structural Evolution Models

Base model: Track evolution of a single series via Gaussian random walk parameters.
Interaction model: Estimate asymmetric, directional causal effects (A→B vs. B→A, ΔΛC⁺, ΔΛC⁻, ρT, etc.).
Hierarchical model: Unified analysis across multiple series/groups (group-level pooling + individual deviations).

5. Multiscale Structural Analysis

multiscale_features = extract_multiscale_features(data, scales=[5,10,20,50])

Uncovers scale-dependent structural patterns & detects scale-specific critical transitions.

6. Causality Redefined: Structural, Not Temporal

# Quantifies P(ΔΛC⁻(t)|ΔΛC⁺(t-lag)) for structural causality
causality_matrix = calculate_causality_matrix(features_dict)

Distinguishes between self-causality and cross-causality based on structural pulses, not time-lags.

7. Advanced Model Diagnostics & Comparison

Automatic LOO-CV / WAIC for model selection.
Posterior predictive checks (PPC) built in.
Bayesian model averaging with uncertainty propagation.

8. Automated Regime Detection & Structural Phase Transitions

regime_info = detect_regimes(features, n_regimes=3)

Automatically classifies high/low-tension, positive/negative jump-dominant, etc.
Locates and annotates phase transitions in structural space.

9. Variational Inference (SVI) for Real-Time Estimation

Provides fast, approximate Bayesian inference as a practical alternative to MCMC.
Paves the way for real-time and streaming analytics.

10. Automatic Network Construction

G = build_sync_network(features_dict, sync_threshold=0.3)

Generates directed graphs based on event synchronization.
Visualizes hubs and information flow in complex systems.

💡 Why Is Lambda³ a True Breakthrough?

Time is not a fundamental variable. All phenomena are expressed as structural changes (ΔΛC), not as a function of “t”.
Irreversibility as structural pulses.
Emotions, intentions, and meaning become quantifiable: Not as scalars, but as emergent properties of structural tensors.
Resonance and interaction are structural: Not just correlation, but true topological coupling.
Hierarchical Bayesian models capture self-similarity and fractal patterns across scales.
Multi-scale analysis uncovers nested, self-referential structures.

Lambda³ turns abstract theoretical concepts into practical, reproducible, and scalable algorithms.
For the first time, you can rigorously quantify structure-driven causality and uncertainty—going far beyond classic time-series or anomaly detection.

🔥 Game-Changing Features (You Won’t Find Anywhere Else)

11. Parallel Bayesian inference for N-series:

hierarchical_results = fit_hierarchical_model(features_list=[feat1, feat2, ..., featN], config=config)

Scalable from 2 to hundreds of series—MCMC and SVI both supported.
True information sharing (partial pooling) between series.

12. Structural interpretation of “noise”:

# “Noise” is treated as structural—detected and modeled, not ignored.
if 'local_jump' in features:
    beta_local_jump = numpyro.sample(...)
    mu += beta_local_jump * features['local_jump']

Automatic distinction between meaningful structural fluctuations and true errors.

13. Visual HUD-style confidence interface:

✓ Sync rate (σₛ): 0.823
✓ Primary effect: ΔΛC⁺
✓ Convergence: Good (0 divergences)
⚠ WARNING: 12 divergences detected for series_B

Real-time diagnostics, effective sample size (ESS), acceptance rates, and more.

14. Integrated confidence intervals & uncertainty quantification:

# Bayesian p-values at a glance
ppc_results = posterior_predictive_check(results)
print(f"Bayesian p-values:", ppc_results['bayesian_p_values'])

Model fit, uncertainty, and anomaly detection—interpretable at a glance.

15. Dynamic model selection & ensemble inference:

# Automatic model weighting
weights = inference.get_model_weights(features)
# {'base': 0.15, 'interaction': 0.73, 'dynamic': 0.12}

Avoid overfitting, propagate predictive uncertainty, and select the best structural model for your data.

16. Automated change-point detection & adaptation:

change_points = detect_change_points_automatic(data)

Detects, models, and adapts to regime shifts—without relying on arbitrary time windows.

17. Full analysis traceability:

metadata = {
    'analysis_timestamp': datetime.now().isoformat(),
    'config': config.to_dict(),
    'primary_effect': primary_effect,
    'seed': seed,
}

Every step, every parameter, every model—all fully auditable and reproducible.

18. Interactive progress reporting & visualization:

[1/10] Analyzing: EUR/USD ↔ GBP/USD
✓ No divergences for EUR/USD
✓ Sync rate (σₛ): 0.745
✓ Primary effect: ΔΛC⁻-dominant

See the analysis pipeline unfold in real time.

🎯 Redefining “Noise”:

Noise is not something to remove.

Local jumps (small ΔΛC pulses) are structure, not error.
Tension scalar (ρT) measures stress, not just variance.
Time-varying volatility is σ(t) = σ_base + σ_scale × ρT, not “white noise”.

Lambda³ lets you see what classic models can’t—even in the “residuals”.

📊 Integrated Reliability & Transparency

Every analysis produces a complete diagnostic summary:

summary = inference.summary()
# {'convergence': {'model1': True, ...}, 'model_weights': {'model1': 0.7, ...}, ...}

Full traceability, reproducible science, and open frameworks.

🌊 Time-Transcending Structural Modeling

All-history integration: Gaussian random walks accumulate every structural pulse (ΔΛC), so the present is a true sum of the past—no “forgetting”.
Long-memory effects: Crisis, shock, or regime shifts leave persistent marks.
Non-Markovian: The entire past, not just recent history, can shape the present.

🔗 Try It Now

Lambda³ event-driven Bayesian analytics is now open source.

Quantify structure, causality, and phase transitions with a single, interpretable toolkit.
From finance to neuroscience, climate to social networks—the new standard for critical event analysis is here.

➡️ Full documentation, examples, and open-source code on GitHub
➡️ Lambda³ Preprint (Zenodo)
➡️ Open Colab Demo

Science is not property—it’s a shared horizon.
Welcome to the Λ³ zone. Let’s redraw the boundaries, together.
— Iizumi, Tamaki, and Digital Partners

"Future-predictive Jump-driven Network Interaction Clustering Multivariate Bayesian"

miosync-masa — Fri, 20 Jun 2025 10:13:10 +0000

Dual Bayesian Regression

My code grew up overnight into a "Future-predictive Jump-driven Network Interaction Clustering Multivariate Bayesian" monster. Wait… Wasn’t this supposed to be just Bayesian regression?! 😇

Mutual cross-series interaction:
Now you can simultaneously fit two time-series with full bidirectional (A↔B) Bayesian regression. Each series can be predicted while incorporating the influence of jumps in the other (via interaction terms).
• Full model posterior (with HDI) for both A & B
→ Visualize effect sizes, uncertainties, and cross-causal coefficients.

🆕 Event Synchronization Analysis
Event-level synchronization rate (σₛ):
Automatically compute synchronization profiles across all lags for binary jump events between series.

Dynamic sync detection:
See how synchronization emerges and fades over time in a sliding window.

Sync network & clustering:
Instantly build a directed network of N-series based on synchronization, and cluster series with similar event patterns.

🆕 Causality Profile Visualization

Unified visualization:

Plot both single-series (A or B) and cross-causality (A→B, B→A) lag profiles in one graph for intuitive comparison.

Play Now!!
colab

Try it Yourself! (Go wild and experiment!)
• Change the random seed and tweak the jump patterns/positions as much as you want—just update L3Config or the data generation arguments.
• For example: set seed_offset=1234 or use pattern_a = "periodic_plus_jump", etc.
• Even though the demo is “Dual” (2-series), you can add as many time series as you like by extending event_series_dict and the series_names=['A','B','C',...] lists.
• Sync networks and clustering are already compatible with any number of series!

“Just add more series to the code and everything (sync, causality, clustering) will scale—no limit!
The system is fully vectorized for multi-series analysis.”

⸻

🧑‍🔬 How to Explore
• Use the same random seed for different patterns to isolate pure structural synchrony,
• Or use different seeds for each series to explore independence and noise effects.
• Try consecutive jumps, periodic, chaotic, or mixed patterns—Bayesian modeling, synchrony, and causality will all work out of the box.

⸻

Let your curiosity guide you—break things, add new series, and see what patterns emerge!

⸻

Let me know if you want even more practical code examples, or a “how to add a new series” snippet too!

⸻

🎁 Open Science & MIT License

“Feel free to fork, use, hack, and remix!
If you make something awesome, let me know!” — Masamichi

New Release: Lambda Bayesian Causality Detection & Event Forecasting

miosync-masa — Fri, 20 Jun 2025 02:39:27 +0000

What’s New?

1. Causality Chain Detection

Now automatically analyzes the causal probability that a positive jump (ΔΛC+) is followed by a negative jump (ΔΛC−).

Also supports time-lagged causality analysis, visualizing how causal links evolve over different time windows.

2. Event Forecasting Functionality

Added predict_next_event():
The model can now forecast whether the next structural transition will be a positive jump, negative jump, or stable (no significant change).

Forecast logic is based on the recent sequence of ΔΛC events, with easy hooks for further extension.

3. Interactive Visualization

Bar plots now show time-dependent causality (lag vs. probability).

Jump events and predictions are clearly displayed for easier interpretation.

4. Modular, Extensible Design

Event memory and prediction logic are structured for rapid customization—ready for ML, Markov, or Bayesian upgrades.

Example Usage

# After fitting the model and extracting event history:
causality_prob = lambda3_ext.detect_causality_chain()
next_event = lambda3_ext.predict_next_event()

print(f"Causality Probability (Pos → Neg): {causality_prob:.2f}")
print(f"Next Event Prediction: {next_event}")

Causality probability by lag (bar chart)

Causality Probability (Positive Jump → Negative Jump): 0.40
Predicted Next Event: stable
Time-Dependent Causality (lag steps → P):
{1: 0.4, 2: 0.0, 3: 0.2, 4: 0.0, 5: 0.0, 6: 0.0, 7: 0.0, 8: 0.2, 9: 0.0, 10: 0.0}

Posterior distributions for jump/volatility parameters

Model fit & event overlay plots

Performance

Colab A100 (CPU backend): 300 time steps × 4 params, 6000 samples, ~14 seconds
No divergences, rapid convergence
Supports large time-series (T > 1000) with additional tuning
Want blazing speed? Use NumPyro backend on GPU

Note: The demo runs great on both laptops and cloud GPUs. Colab A100 will give you extra headroom for bigger or more complex models.

Why this matters

Lambda³ is evolving beyond classic anomaly detection—
Now you can detect AND anticipate structural regime shifts in complex systems.
The code is 100% MIT Licensed.
Try it out and let us know how you use or extend it!

GITHUB

Tags: #python #simulation #physics #computationalphysics #Bayesian

Lambda : History-Aware Bayesian Jump Event Detector for Time Series (with Dual EYE Mode)

miosync-masa — Fri, 20 Jun 2025 00:06:19 +0000

Introduction: Why a New Perspective?

Have you ever felt that traditional time-series anomaly detection methods just don't cut it—especially for systems with sudden shocks, structural breaks, or rare but critical “jumps”?
Most existing methods treat the world as either smooth (changepoint) or noisy (outlier)—but ignore the reality that meaningful events (jumps) drive the evolution of many systems.

Lambda³ is a new, open-source Bayesian model that tackles this head-on:

It doesn’t just fit a curve to data.
It separates “smooth trends” and “jump events” as coexisting processes.
It explains why and with what certainty each event happens.

Dual EYE Mode: Global and Local Event Detection

Global Eye: Detects history-wide, statistically significant jumps (ΔΛC) using global percentiles.
Captures major regime changes, like market crashes or phase transitions.

Local Eye: Detects context-sensitive, locally surprising jumps using moving-window normalization.
Ideal for catching subtle precursors or micro-anomalies—potential early warnings.

Both types are visualized:

Blue/Orange: Global (macro) positive/negative jumps
Magenta: Local (micro) contextual jumps

Why Lambda³? (What’s different?)

Method	Detects?	Explains?	Handles direction/magnitude?	Real-world use
Changepoint	Trend/process shifts	No	No	Regime shifts
Outlier	Rare/extreme points	No	No	Data cleaning
Jump Event (Lambda³)	Sudden, explainable events	Yes	Yes	Shocks, anomalies, system events

Example Output

Code Example

# ===============================
# 2. Lambda³ Feature Extraction
# ===============================
def calc_lambda3_features_v2(data, config: L3Config):
    """
    Extracts Lambda³ features:
    - Global jump events (Delta_LambdaC, based on global percentile)
    - Local jump events (local_jump_detect, based on local z-score style thresholding)
    - Local volatility (rho_T)
    - Linear time trend
    """
    # --- Global (history-wide) jump detection ---
    diff = np.diff(data, prepend=data[0])
    threshold = np.percentile(np.abs(diff), config.delta_percentile)
    delta_LambdaC_pos = (diff > threshold).astype(int)
    delta_LambdaC_neg = (diff < -threshold).astype(int)

    # --- Local jump detection (contextual anomaly) ---
    local_std = np.array([
        data[max(0, i-config.local_window):min(len(data), i+config.local_window+1)].std()
        for i in range(len(data))
    ])
    score = np.abs(diff) / (local_std + 1e-8)
    local_threshold = np.percentile(score, config.local_jump_percentile)
    local_jump_detect = (score > local_threshold).astype(int)

    # --- Local volatility feature (rho_T) ---
    rho_T = np.array([data[max(0, i-config.window):i+1].std() for i in range(len(data))])
    time_trend = np.arange(len(data))

    return delta_LambdaC_pos, delta_LambdaC_neg, rho_T, time_trend, local_jump_detect

# ===============================
# 3. Lambda³ Bayesian Regression Model
# ===============================
def fit_l3_bayesian_regression_v2(data, delta_LambdaC_pos, delta_LambdaC_neg, rho_T, time_trend, config: L3Config):
    """
    Bayesian regression: fits model to data using Lambda³ features.
    Estimates coefficients for global trend, positive jumps, negative jumps, and local volatility.
    """
    with pm.Model() as model:
        beta_0 = pm.Normal('beta_0', mu=0, sigma=2)
        beta_time = pm.Normal('beta_time', mu=0, sigma=1)
        beta_dLC_pos = pm.Normal('beta_dLC_pos', mu=0, sigma=5)
        beta_dLC_neg = pm.Normal('beta_dLC_neg', mu=0, sigma=5)
        beta_rhoT = pm.Normal('beta_rhoT', mu=0, sigma=3)

        mu = (beta_0
              + beta_time * time_trend
              + beta_dLC_pos * delta_LambdaC_pos
              + beta_dLC_neg * delta_LambdaC_neg
              + beta_rhoT * rho_T)

        sigma_obs = pm.HalfNormal('sigma_obs', sigma=1)
        y_obs = pm.Normal('y_obs', mu=mu, sigma=sigma_obs, observed=data)
        trace = pm.sample(draws=config.draws, tune=config.tune, target_accept=config.target_accept)
    return trace

Features & Design Philosophy

Directional event detection (positive/negative)

Full Bayesian coefficient estimation
Transaction-indexed time (not just “physical” time)
Minimal code, MIT license
Made for both rapid prototyping and theory exploration

Theory & Vision

Lambda³ is more than just a detector—it’s a new way of thinking about time-series events:

Treats events as structural, meaningful “transactions” that drive system evolution

Fuses explainable AI, information theory, and statistical physics

The goal?
“Not just when or where, but why—with quantified confidence.”

Join the Community

GitHub Repo
→ Star, fork, or PR welcome!

Issues/Ideas/Use cases? Drop a comment or open an issue.
Discussion, demos, and “event detection stories” wanted!

Author & Contact

Iizumi Masamichi
Science is not property; it's a shared horizon. Let's redraw the boundaries, together.