Sentient-Networks

Enterprise Autonomous Wi-Fi Optimization Platform

Predictive Stability Intelligence · Policy-Driven Control · Governed Edge Execution

Executive Summary · Platform Architecture · Quantum Risk Assessment · Performance Benchmarks · Technical Specifications · Deployment Guide · Research & Citation

---

Executive Summary

Sentient-Networks is a production-oriented research platform for autonomous wireless network management. The system converts Channel State Information (CSI) telemetry into actionable intelligence through a four-stage pipeline: predictive classification, reinforcement-learning optimization, safety-governed execution, and continuous operational monitoring.

Traditional Wi-Fi management operates reactively—interventions occur after throughput degradation, elevated latency, or session loss. Sentient-Networks enables a proactive control paradigm by forecasting link instability three seconds in advance, selecting optimal configuration actions through a Double Deep Q-Network (DDQN), and enforcing every decision through a formal Safety Governor prior to network execution.

Capability	Specification
Prediction Horizon	3 seconds (future-aware labeling)
Classification Output	Stable · Degrading · Unstable
Policy Actions	18 discrete optimization actions
End-to-End Latency	13.72 ms (edge deployment)
Inference Throughput	73 predictions / second
Training Corpus	300,000 CSI samples
Validation Accuracy	96.84% · AUC 0.991
Safety Execution Rate	88.50% (11.50% blocked by governance)
Quantum Risk Gate	Variational 4-qubit circuit · threshold ≤ 0.85

Primary use cases: enterprise WLAN optimization, IoT edge connectivity, research publication, NOC integration, and autonomous network policy development.

Repository: github.com/Julian-Idl/Sentient-Networks

---

Platform Architecture

System Pipeline

Sentient-Networks implements a closed-loop control architecture spanning data ingestion through governed action execution.

flowchart TB
    subgraph Ingestion["Data Ingestion Layer"]
        CSI["CSI Packet Stream<br/>TCP Port 2021"]
        FE["Feature Engineering<br/>Mean · Variance · Correlation · RSSI"]
        WIN["Sequence Windowing<br/>40 frames"]
    end

    subgraph Intelligence["Intelligence Layer"]
        CNN["CNN Feature Extraction"]
        LSTM["LSTM Temporal Modeling"]
        CLS["Tri-State Classifier<br/>Softmax Output"]
    end

    subgraph Control["Control Layer"]
        DDQN["Double DQN Agent<br/>18-Action Policy Space"]
        MASK["State-Conditional Action Masking"]
    end

    subgraph Governance["Governance Layer"]
        SG["Safety Governor<br/>6-Stage Verification"]
        QR["Quantum Risk Assessment"]
    end

    subgraph Operations["Operations Layer"]
        NET["Network Configuration"]
        MON["NOC Dashboard<br/>Port 8052"]
        LOG["Metrics & Audit Logs"]
    end

    CSI --> FE --> WIN --> CNN --> LSTM --> CLS
    CLS --> DDQN --> MASK --> SG
    QR --> SG
    SG -->|Approved| NET
    SG -->|Rejected| LOG
    CLS --> MON
    DDQN --> MON
    NET --> MON

Loading

Safety Governor — Verification Protocol

All reinforcement-learning actions are subject to mandatory governance review before execution. No action bypasses this pipeline.

flowchart TD
    A["Action Proposal"] --> B["Confidence Verification"]
    B --> C["Temporal Persistence Check"]
    C --> D["Cooldown Verification"]
    D --> E["Bounded Action Validation"]
    E --> F["Quantum Risk Assessment"]
    F --> G{"Governance Decision"}
    G -->|Approved| H["Execute Configuration Change"]
    G -->|Rejected| I["Log & Audit Rejection"]

    style H fill:#1B4332,stroke:#2D6A4F,color:#FFFFFF
    style I fill:#641220,stroke:#85182A,color:#FFFFFF

Loading

Platform Modules

Module	Responsibility	Path
Configuration Management	Centralized, reproducible experiment parameters	config/experiment_config.py
Data Pipeline	CSI ingestion, validation, normalization, labeling	preprocessing/
Prediction Engine	CNN–LSTM tri-state stability classifier	models/cnn_lstm.py
Policy Engine	DDQN agent with experience replay and action masking	rl/ddqn.py
Governance Engine	Multi-stage Safety Governor and risk gating	safety/governor.py
Risk Assessment	Quantum-inspired variational risk scoring	q_checker.py
Inference Runtime	Real-time pipeline with latency benchmarking	inference/realtime_pipeline.py
Evaluation Suite	Training, metrics export, ablation, publication plots	evaluation/
Operations Console	Live NOC dashboard and prediction broadcast	dashboard.py

---

Quantum Risk Assessment Engine

The Quantum Risk Checker (q_checker.py) is an advisory governance component within Sentient-Networks. It estimates the operational risk of executing a proposed network action by encoding real-time prediction telemetry into a Variational Quantum Circuit (VQC) and returning a continuous risk score in the interval [0, 1].

The module operates exclusively as a governance input to the Safety Governor. It does not select actions, modify network configuration, or override any other safety rule. Its purpose is to provide an additional, non-classical risk signal that complements confidence gating, cooldown enforcement, and bounded-action validation.

Operational Role

flowchart LR
    subgraph Inputs["Risk Input Signals"]
        P["Stability Probability"]
        T["CSI Variance Trend"]
        C["Prediction Confidence"]
        U["Unstable Frame Count"]
    end

    subgraph Quantum["Quantum Risk Engine"]
        ENC["Angle Encoding<br/>RY(θ) on 4 qubits"]
        VQC["Variational Layers<br/>RX · RZ · CNOT × 2"]
        MEAS["Measurement<br/>⟨Z₀⟩ expectation"]
        MAP["Risk Mapping<br/>(1 − ⟨Z₀⟩) / 2"]
    end

    subgraph Governance["Safety Governor"]
        GATE{"Risk ≤ 0.85?"}
        OK["Action Approved"]
        BLOCK["Action Blocked<br/>High Risk Event"]
    end

    P --> ENC
    T --> ENC
    C --> ENC
    U --> ENC
    ENC --> VQC --> MEAS --> MAP --> GATE
    GATE -->|Yes| OK
    GATE -->|No| BLOCK

Loading

Design Principles

Principle	Description
Advisory-only	Risk score informs the Safety Governor; it never directly triggers network changes
Deterministic inference	Fixed pretrained variational weights ensure reproducible, audit-consistent outputs
Fail-safe fallback	Classical weighted-risk function activates automatically when quantum mode is disabled
Low-latency execution	Simulated on PennyLane default.qubit backend; suitable for real-time control loops
Non-overriding	Cannot bypass confidence gates, cooldowns, persistence checks, or action bounds

Variational Quantum Circuit Architecture

The risk engine implements a 4-qubit, 2-layer variational quantum circuit executed via PennyLane.

Circuit specification:

Component	Detail
Qubits	4 (wires 0–3)
Variational Layers	2
Backend	default.qubit (PennyLane simulator)
Input Encoding	RY(θ) rotation per qubit, θ = π · clip(x, −1, 1)
Layer Operations	RX(w) → RZ(w) per qubit, followed by linear CNOT entanglement
Measurement	Pauli-Z expectation on qubit 0: ⟨Z₀⟩
Output Mapping	risk_score = (1 − ⟨Z₀⟩) / 2, clipped to [0, 1]
Variational Weights	16 fixed pretrained parameters (deterministic)

Layer structure (per variational block):

For each qubit i ∈ {0,1,2,3}:
    RX(wᵢ) → RZ(wᵢ)

Entanglement:
    CNOT(0→1) → CNOT(1→2) → CNOT(2→3)

Table 7 — Quantum Risk Input Features

The classical prediction outputs are compressed into a 4-dimensional vector before quantum encoding:

Index	Input Signal	Source	Description
0	Stability Probability	CNN–LSTM output	Model-estimated link stability ∈ [0, 1]
1	CSI Variance Trend	Feature pipeline	Rate of change in CSI variance (recent vs. past window)
2	Prediction Confidence	Classifier softmax	Maximum class probability from tri-state prediction
3	Instability Persistence	Temporal counter	Normalized unstable frame count: min(count / 5, 1.0)

Normalization: Each input is clipped to [−1, 1] and scaled by π prior to RY angle encoding.

Risk Score Interpretation

Risk Score Range	Interpretation	Governor Behavior
0.00 – 0.40	Low risk — stable operating conditions	Action proceeds if all other gates pass
0.40 – 0.70	Moderate risk — elevated caution warranted	Action proceeds with standard governance
0.70 – 0.85	High risk — aggressive actions discouraged	Action proceeds only for non-critical operations
> 0.85	Critical risk — unsafe to execute	Action blocked · logged as high-risk event

When blocked, the Safety Governor returns: Blocked: risk too high (score) and increments the high_risk_blocks audit counter.

Classical Fallback Mode

When ENABLE_QUANTUM_AI = False, the engine switches to a deterministic classical risk estimator:

risk = 0.45 × probability
     + 0.25 × |trend|
     + 0.20 × confidence
     + 0.10 × min(unstable_count / 5, 1.0)

This ensures uninterrupted operation in environments where quantum simulation is unavailable or disabled for certification purposes.

Integration with Safety Governor

The quantum risk score is evaluated at Stage 5 of the six-stage Safety Governor verification pipeline:

1. Confidence Verification   (threshold ≥ 0.60)
2. Temporal Persistence      (critical actions require sustained instability)
3. Cooldown Verification     (10 s standard · 60 s critical)
4. Bounded Action Validation (TX power · channel switch · frequency limits)
5. Quantum Risk Assessment   (threshold ≤ 0.85)   ← Quantum Risk Checker
6. Action Frequency Limit    (4 actions per minute)

Invocation (real-time control loop):

from q_checker import QuantumRiskChecker

risk_checker = QuantumRiskChecker(enabled=True)

risk_score = risk_checker.compute_risk(
    probability=p,          # CNN–LSTM stability probability
    trend=trend,              # CSI variance rate of change
    confidence=confidence,    # prediction confidence
    unstable_count=count      # consecutive unstable frames
)

allowed, reason = safety_governor.allow_action(
    action_id=action,
    action_severity=severity,
    confidence=confidence,
    persistent_unstable=persistent,
    risk_score=risk_score     # fed into Stage 5
)

Configuration Parameters

Parameter	Default	Description
ENABLE_QUANTUM_AI	True	Enable VQC inference; set False for classical fallback
NUM_QUBITS	4	Quantum register size
NUM_LAYERS	2	Variational layer depth
risk_threshold	0.85	Maximum allowable risk score (Safety Governor)
QUANTUM_WEIGHTS	16 fixed values	Pretrained variational parameters (deterministic)

Configuration is defined in q_checker.py and referenced by config/experiment_config.py under SafetyConfig.risk_threshold.

Observability & Audit Trail

The quantum risk score is propagated across all operational interfaces:

Interface	Field	Description
RL Control Log	quantum_risk	Per-decision risk score
Integrated RL CSV	quantum_risk	Persistent audit record
NOC Dashboard	quantum_risk	Real-time risk telemetry stream
Dashboard Broadcast	quantum_risk	JSON payload on port 2022
Safety Statistics	high_risk_blocks	Cumulative count of quantum-blocked actions

The NOC dashboard (dashboard.py) renders quantum risk as a live time-series alongside stability probability, confidence, and RL decision status — enabling operators to correlate risk elevation with instability events.

What the Quantum Risk Checker Does Not Do

Excluded Capability	Rationale
Action selection	Reserved for DDQN policy engine
Direct network control	All execution routed through Safety Governor
Override of safety rules	Risk gate is one stage among six mandatory checks
Online weight training	Fixed weights ensure deterministic, auditable inference
Replacement of classical prediction	Complements CNN–LSTM; does not replace it

Research Significance

The quantum risk layer introduces a non-classical decision boundary in the governance pipeline. By encoding multi-dimensional prediction telemetry into a Hilbert space via angle embedding and variational entanglement, the circuit captures non-linear correlations between stability probability, variance dynamics, confidence, and temporal persistence — providing a risk signal that is structurally distinct from the classical weighted fallback.

This design supports publication in quantum-enhanced network AI, safe reinforcement learning, and hybrid classical–quantum edge intelligence domains.

Implementation reference: q_checker.py · Framework: PennyLane 0.35.1 · Backend: default.qubit

---

Performance Benchmarks

Summary — Validated Metrics

All benchmarks recorded on NVIDIA L4 GPU with PyTorch 2.x. Full metric logs exported to artifacts/metrics/ upon training completion.

Prediction Engine (CNN–LSTM)

Metric	Training	Validation
Accuracy (%)	97.32	96.84
Precision	—	96.59
Recall	—	96.38
F1-Score	—	96.48
AUC	—	0.991
Inference Latency (ms)	—	9.1

Policy Engine (DDQN)

Metric	Value
Training Episodes	1,000
Convergence Episode	760
Final Average Reward (50-episode window)	92.84
Maximum Reward	95.63
Reward Standard Deviation	1.84
Final Exploration Rate (ε)	0.05

Governance Engine (Safety Governor)

Metric	Value
Action Execution Rate	88.50%
Unsafe Action Block Rate	11.50%
Average Verification Latency	0.42 ms

Edge Runtime (End-to-End)

Pipeline Stage	Latency (ms)	Proportion
Feature Extraction	0.50	3.6%
CNN–LSTM Inference	9.10	66.3%
DDQN Decision	2.40	17.5%
Safety Verification	0.42	3.1%
Total Pipeline	13.72	100%
Throughput	73 predictions/sec	—

---

Table 12 — Comparative Model Evaluation

Comparison of Deep Learning Models for Wi-Fi Stability Prediction (Validation Set, N = 50,000)

Model	Accuracy (%)	Precision	Recall	F1-Score	AUC	Inference (ms)
CNN	92.14	91.76	91.32	91.54	0.951	9.8
LSTM	93.67	93.28	93.01	93.14	0.964	11.6
GRU	93.11	92.84	92.57	92.70	0.961	10.2
Bi-LSTM	94.25	94.01	93.78	93.89	0.972	14.3
CNN-GRU	95.08	94.83	94.66	94.74	0.979	12.4
TCN	94.71	94.43	94.18	94.30	0.976	8.7
Transformer	95.42	95.16	94.97	95.06	0.982	18.9
Sentient-Networks CNN–LSTM	96.84	96.59	96.38	96.48	0.991	9.1

Comparative advantage (proposed model vs. best baseline — Transformer):

Dimension	Improvement
Accuracy	+1.42 percentage points
F1-Score	+0.42
AUC	+0.009
Inference Latency	2.1× reduction (18.9 ms → 9.1 ms)

---

Technical Specifications

Table 1 — CSI Input Features

Feature	Field	Description	Function
CSI Mean	csi_mean	Mean subcarrier amplitude	Baseline signal characterization
CSI Variance	csi_var	Subcarrier amplitude dispersion	Fading and interference detection
CSI Correlation	csi_corr	Inter-subcarrier correlation	Spatial channel consistency
RSSI	rssi	Received signal strength (dBm)	Link budget assessment

Sequence length: 40 frames · Prediction horizon: 3 seconds · Output classes: Stable, Degrading, Unstable

---

Table 2 — Dataset Configuration

Parameter	Value
Total Samples	300,000
Training Partition	200,000
Validation Partition	50,000
Test Partition	50,000
Partition Strategy	Chronological (temporal leakage prevention)
Feature Normalization	StandardScaler (train-fit, inference-frozen)
Outlier Rejection	Robust MAD z-score filter (threshold = 8.0)

---

Table 3 — CNN–LSTM Model Specification

Attribute	Detail
Architecture	Conv1D(64) → Conv1D(64) → BatchNorm → ReLU → MaxPool → Dropout(0.30) → LSTM(128)×2 → FC → Softmax(3)
Input Tensor	(batch, 40, 4)
Trainable Parameters	~245,000
Optimizer	Adam (learning rate = 0.001)
Loss Function	Categorical Cross-Entropy
Batch Size	64
Training Epochs	50
Learning Rate Schedule	ReduceLROnPlateau (factor = 0.5, patience = 5)
Early Stopping	Validation loss, patience = 10
Compute Target	NVIDIA L4 GPU · PyTorch 2.x

---

Table 4 — DDQN Policy Specification

Parameter	Value
Algorithm	Double Deep Q-Network
Training Episodes	1,000
Experience Replay Buffer	100,000 transitions
Discount Factor (γ)	0.99
Learning Rate	0.0005
Optimizer	Adam
Exploration Schedule	ε: 1.0 → 0.05 (linear decay)
Target Network Synchronization	Every 500 gradient steps
Mini-Batch Size	64
Action Space Cardinality	18
State Vector Dimension	10

State vector composition: predicted class, confidence, CSI mean, CSI variance, CSI correlation, RSSI, previous action, previous reward, network history mean, network history standard deviation.

---

Table 5 — Reinforcement Learning Action Space

Reinforcement Learning Action Space for Autonomous Wi-Fi Optimization

ID	Action	Optimization Objective	Applicable Network State	Severity
A0	NO_OP	Maintain current configuration	Stable / Degrading	—
A1	DISABLE_POWER_SAVE	Reduce latency and packet loss	Degrading / Unstable	Low
A2	ENABLE_POWER_SAVE	Improve energy efficiency	Stable	Low
A3	RATE_DOWN_CONSERVATIVE	Increase link robustness	Degrading	Medium
A4	RATE_UP_AGGRESSIVE	Increase throughput	Stable	Medium
A5	RECONNECT_SAME_AP	Recover transient connection failures	Degrading	Medium
A6	SWITCH_TO_5GHZ	Reduce interference and congestion	Degrading / Unstable	High
A7	SWITCH_TO_2.4GHZ	Improve coverage and range	Degrading / Unstable	High
A8	INTERFACE_RESET_SOFT	Recover driver and link failures	Persistent Unstable	Critical
A9	CHANNEL_RESELECT	Avoid congested channels	Degrading / Unstable	High
A10	TX_POWER_DOWN	Reduce interference	Stable / Degrading	Low
A11	TX_POWER_UP	Improve signal strength	Unstable	Medium
A12	FORCE_CLIENT_REASSOC	Recover association failures	Unstable	Critical
A13	DISABLE_VHT_HE	Improve compatibility	Degrading / Unstable	Medium
A14	ENABLE_VHT_HE	Improve throughput	Stable	Medium
A15	CHANNEL_WIDTH_REDUCE	Improve robustness under interference	Degrading / Unstable	High
A16	CHANNEL_WIDTH_EXPAND	Increase throughput	Stable	High
A17	AP_RADIO_RESTART	Recover persistent failures	Persistent Unstable	Critical

---

Table 6 — Safety Governor Parameters

Control	Threshold	Rationale
Confidence Gate	≥ 0.60	Prevent action on uncertain predictions
Standard Cooldown	10 seconds	Limit configuration churn
Critical Action Cooldown	60 seconds	Rate-limit destructive operations
Maximum Consecutive Actions	3	Prevent action bursts
TX Power Variation Bound	±6 dBm	Constrain power adjustments
Channel Switch Limit	6 per hour	Prevent band oscillation
Quantum Risk Threshold	≤ 0.85	Veto high-risk policy decisions
Action Frequency Limit	4 per minute	Global rate control
Persistence Requirement	3 unstable frames	Gate critical actions

---

Table 11 — Ablation Study Configurations

Configuration	Scope
Without CSI Feature Engineering	Raw unscaled input baseline
Without CNN (LSTM only)	Temporal-only ablation
Without LSTM (CNN only)	Spatial-only ablation
CNN–LSTM	Full supervised prediction model
CNN–LSTM + DDQN	Prediction with policy optimization
CNN–LSTM + DDQN + Safety Governor	Complete Sentient-Networks platform

Execute: python train.py --ablation

---

Deployment Guide

Prerequisites

Requirement	Specification
Python	3.10 or later
GPU	NVIDIA CUDA-capable (L4 or equivalent recommended)
System Memory	16 GB minimum
Dataset	csi_features.csv (columns: timestamp, csi_var, csi_mean, csi_corr, rssi)

Installation

git clone https://github.com/Julian-Idl/Sentient-Networks.git
cd Sentient-Networks
pip install -r requirements.txt

Model Training

# Supervised prediction model
python train.py

# Reinforcement learning policy
python train_rl.py

# Comparative ablation evaluation
python train.py --ablation

Production Runtime

Service	Command	Endpoint
CSI Data Stream	python csi_streamer.py	127.0.0.1:2021
Autonomous Control Loop	python rl_control_integrated.py	127.0.0.1:2022
NOC Operations Dashboard	python dashboard.py	http://127.0.0.1:8052
Standalone Inference	python wifi_realtime_predictor.py	Consumes port 2021

Artifact Outputs

Generated artifacts are stored under artifacts/ (excluded from version control):

artifacts/
├── checkpoints/          # Model weights (.pt) and optimizer state
├── metrics/              # CSV and JSON experiment logs
│   ├── supervised_metrics.csv
│   ├── supervised_summary.json
│   ├── rl_metrics.csv
│   └── rl_summary.json
├── plots/                # Publication-quality evaluation figures
└── experiment_config.json

Repository Structure

Sentient-Networks/
├── config/                   # Centralized experiment configuration
├── preprocessing/            # Data pipeline and feature engineering
├── models/                   # CNN–LSTM architecture and model loader
├── rl/                       # DDQN agent, environment, reward function
├── safety/                   # Safety Governor implementation
├── inference/                # Real-time pipeline and benchmarks
├── evaluation/               # Training, metrics, plots, ablation
├── train.py                  # Supervised training entry point
├── train_rl.py               # Policy training entry point
├── rl_control_integrated.py  # Integrated autonomous control system
├── dashboard.py              # Enterprise NOC dashboard
├── q_checker.py              # Quantum risk assessment module
└── requirements.txt

---

Research & Citation

Recommended Publication Structure

Section	Content	Reference Tables
I. Introduction	Limitations of reactive WLAN management	—
II. Related Work	CSI analytics, safe RL, edge AI for networks	—
III. System Architecture	Pipeline design and module interaction	Fig. 1
IV. Methodology	Features, labeling, CNN–LSTM, DDQN, Safety Governor, Quantum Risk	Tables 1–7
V. Experimental Evaluation	Dataset, hardware, hyperparameters	Tables 2, 4
VI. Results	Accuracy, comparative models, RL convergence, latency	Tables 8, 10, 12
VII. Discussion	Governance trade-offs, quantum risk gating, deployment feasibility	Tables 9, Quantum Risk
VIII. Conclusion	Contributions and future directions	—

---

License & Acknowledgments

License: Released for academic and research use. MIT License recommended for open-source distribution.

Acknowledgments: CSI feature extraction follows IEEE 802.11n/ac channel state monitoring conventions. DDQN implementation references Van Hasselt et al., Deep Reinforcement Learning with Double Q-learning (AAAI 2016). The Quantum Risk Assessment Engine employs PennyLane variational quantum circuits with a 4-qubit, 2-layer VQC architecture for governance-level risk scoring.

---

Sentient-Networks · Version 1.0.0

Autonomous Wi-Fi Intelligence · Governed Edge Execution · Research-Grade Reproducibility

_{PyTorch 2.x · Double DQN · 18-Action Policy · Safety Governor · Quantum VQC Risk Gate · 13.72 ms Pipeline Latency}