┌─────────────────────────────────────────────────────────────┐
│                    应用交互层 (Application)                    │
│  会议业务逻辑 · 多流订阅策略 · 画面布局引擎 · 统计上报 SDK      │
├─────────────────────────────────────────────────────────────┤
│                    智能决策层 (RL Agent)                       │
│  状态编码器 → 策略网络 (Actor) → 动作分布 → 分层决策输出        │
│  价值网络 (Critic) ← 奖励计算 ← 环境反馈 (QoE/带宽/丢包)       │
├─────────────────────────────────────────────────────────────┤
│                    网络感知层 (Network Telemetry)              │
│  带宽预测器 (Kalman/LSTM) · 丢包率估计器 · RTT 抖动分析器      │
│  拥塞信号提取 (ECN/TCP_INFO/QUIC Spin Bit)                    │
├─────────────────────────────────────────────────────────────┤
│                    编码执行层 (Media Engine)                   │
│  SVC 编码器 (VP9/SVC, H.264/SVC, AV1 Scalability)             │
│  分层包调度器 · NACK/FEC 重传引擎 · 关键帧强制刷新控制         │
└─────────────────────────────────────────────────────────────┘

// 伪代码：SVC 分层决策映射到编码器参数
struct SVCLayerDecision {
    int spatial_layer_id;      // 0: 180p, 1: 360p, 2: 720p, 3: 1080p
    int temporal_layer_id;     // 0: 5fps, 1: 15fps, 2: 30fps
    int snr_layer_id;          // 量化步长偏移
    bool drop_eligible;        // 是否允许丢弃增强层
    int target_bitrate_kbps;   // 目标码率上限
};

void apply_svc_decision(EncoderContext* ctx, const SVCLayerDecision& decision) {
    ctx->set_spatial_layers(decision.spatial_layer_id + 1);
    ctx->set_temporal_layers(decision.temporal_layer_id + 1);
    ctx->set_qp_offset(decision.snr_layer_id * QP_STEP);
    ctx->set_bitrate_cap(decision.target_bitrate_kbps * 1000);
    ctx->enable_drop_enhancement(decision.drop_eligible);
}

动作 = {离散分层选择: 4(空间) × 3(时间) × 2(SNR) = 24 种组合,
        连续码率调节因子: α ∈ [0.5, 1.5]}

# PPO 训练配置片段
algorithm: "PPO-Clip"
network:
  actor: [512, 256, 128] + GRU(128)  # 共享编码器 + 循环策略头
  critic: [512, 256, 128] + GRU(128)
  
hyperparameters:
  learning_rate: 3e-4 (linear decay)
  gamma: 0.99
  gae_lambda: 0.95
  clip_epsilon: 0.2
  entropy_coef: 0.01 (decay to 0.001)
  max_grad_norm: 0.5
  ppo_epochs: 4
  minibatch_size: 2048
  
# 安全约束
safety_shield:
  max_bitrate_change_pct: 0.3      # 单步码率变化上限 30%
  min_keyframe_interval_sec: 2.0   # 强制关键帧间隔下限
  freeze_penalty_threshold: 3      # 连续冻结帧数触发熔断

┌──────────────────┐     gRPC/共享内存      ┌──────────────────┐
│  Media Server    │ ◄─────────────────────► │  RL Inference    │
│  (Janus/Mediasoup│   状态上报 / 动作下发    │  Service         │
│   /Custom)       │                         │  (ONNX Runtime)  │
└──────────────────┘                         └────────┬─────────┘
                                                      │
                              ┌───────────────────────┼───────────────────────┐
                              ▼                       ▼                       ▼
                       ┌─────────────┐         ┌─────────────┐         ┌─────────────┐
                       │ 规则兜底引擎 │         │ 监控告警系统 │         │ A/B 实验平台 │
                       │ (Heuristic   │         │ (Prometheus │         │ (分层实验、  │
                       │  Fallback)   │         │  + Grafana) │         │  灰度发布)   │
                       └─────────────┘         └─────────────┘         └─────────────┘

时间轴 (秒)    0    10    20    30    40    50    60
基线策略:    [720p30]→[360p15]→[冻结]→[180p5]→[冻结]→[360p15]→[720p30]
RL 策略:     [360p30]→[360p30]→[180p15]→[360p15]→[360p30]→[540p30]→[720p30]
             ↑平滑降级   ↑保持帧率  ↑保基础层  ↑渐进恢复  ↑利用增强层 ↑满带宽

class DualStreamCausalEncoder(nn.Module):
    def __init__(self, state_dim, hist_len=10, d_model=256, n_heads=4):
        super().__init__()
        # 流 1: 网络状态流 (高频、强相关)
        self.net_encoder = nn.Sequential(
            nn.Linear(8, d_model // 2), nn.LayerNorm(d_model // 2), nn.GELU()
        )
        # 流 2: 编码/QoE 状态流 (低频、离散事件驱动)
        self.qoe_encoder = nn.Sequential(
            nn.Linear(19, d_model // 2), nn.LayerNorm(d_model // 2), nn.GELU()
        )
        # 因果自注意力: 显式建模时序因果性, 禁止未来信息泄露
        self.causal_attn = nn.MultiheadAttention(d_model, n_heads, batch_first=True)
        self.register_buffer("causal_mask", torch.triu(torch.ones(hist_len, hist_len) * float('-inf'), diagonal=1))
        
        # 输出头
        self.policy_head = nn.Linear(d_model, 24)  # 离散分层 logits
        self.beta_head = nn.Linear(d_model, 2)     # 连续码率因子 Beta 分布参数
        self.value_head = nn.Linear(d_model, 1)

    def forward(self, net_feat_seq, qoe_feat_seq):
        # net_feat_seq: [B, T, 8], qoe_feat_seq: [B, T, 19]
        h_net = self.net_encoder(net_feat_seq)
        h_qoe = self.qoe_encoder(qoe_feat_seq)
        h = torch.cat([h_net, h_qoe], dim=-1)  # [B, T, D]
        
        # 因果注意力聚合历史
        h_attn, _ = self.causal_attn(h, h, h, attn_mask=self.causal_mask[:h.size(1), :h.size(1)])
        h_last = h_attn[:, -1, :]  # 取最后一步作为当前决策特征
        
        return {
            'layer_logits': self.policy_head(h_last),
            'beta_params': F.softplus(self.beta_head(h_last)) + 1.0,  # 保证 alpha, beta > 1
            'value': self.value_head(h_last).squeeze(-1)
        }

// Rust 伪代码: 高性能 Shield Layer (嵌入 Media Server 进程内, 延迟 < 50us)
pub struct SafetyShield {
    max_bitrate_ratio: f32,      // 相对 pacing_rate 上限
    max_layer_jump: i32,         // 空间层单步最大跳变
    min_keyframe_interval: Duration,
    last_keyframe_ts: Instant,
    last_layer: SpatialLayer,
}

impl SafetyShield {
    pub fn project(&mut self, rl_action: SVCLayerDecision, pacing_rate_bps: u64, now: Instant) -> SVCLayerDecision {
        let mut safe_action = rl_action;
        
        // 1. 码率硬约束: 不得超过拥塞控制模块给出的 pacing_rate
        let max_allowed = (pacing_rate_bps as f32 * self.max_bitrate_ratio) as u32;
        safe_action.target_bitrate_kbps = safe_action.target_bitrate_kbps.min(max_allowed / 1000);
        
        // 2. 空间层跳变约束: 防止剧烈分辨率跳变导致解码器重置/花屏
        let layer_diff = (safe_action.spatial_layer_id as i32 - self.last_layer as i32).abs();
        if layer_diff > self.max_layer_jump {
            safe_action.spatial_layer_id = if safe_action.spatial_layer_id > self.last_layer as u8 {
                (self.last_layer as u8 + self.max_layer_jump as u8).min(3)
            } else {
                (self.last_layer as u8).saturating_sub(self.max_layer_jump as u8)
            };
        }
        
        // 3. 关键帧间隔保护: 强制周期性 IDR, 防止长期无关键帧导致错误蔓延
        if now.duration_since(self.last_keyframe_ts) > self.min_keyframe_interval {
            safe_action.force_keyframe = true;
            self.last_keyframe_ts = now;
        }
        
        self.last_layer = safe_action.spatial_layer_id.into();
        safe_action
    }
}

# 合法拓扑预计算 (离线生成)
VALID_TOPOLOGIES = [
    # (spatial_id, max_temporal_id, snr_id, desc)
    (0, 0, 0), (0, 1, 0), (0, 2, 0),  # 180p @ 5/15/30fps
    (1, 0, 0), (1, 1, 0), (1, 2, 0), (1, 2, 1), # 360p ...
    (2, 0, 0), (2, 1, 0), (2, 2, 0), (2, 2, 1), # 720p ...
    (3, 0, 0), (3, 1, 0), (3, 2, 0), (3, 2, 1), # 1080p ...
]

def apply_action_mask(logits, valid_mask):
    logits[~valid_mask] = -1e9
    return logits

标准 IPPP:    I -> P1 -> P2 -> P3 -> P4 ... (单链, 任一丢包导致后续全溃)
Pyramid (TL0/TL1/TL2):
    TL0: I ----------> P ----------> P ----------> P  (关键帧/基础帧, 低帧率, 极强鲁棒)
    TL1:      -> B ->       -> B ->       -> B      (中间层, 参考 TL0)
    TL2:         -> b -> b ->       -> b -> b       (高帧率层, 参考 TL1, 可丢弃)

// Media Server 内部接口定义
struct CongestionControlFeedback {
    uint64_t pacing_rate_bps;      // 硬上限: RL 目标码率不得超过
    uint64_t available_bandwidth_bps; // 软参考: RL 奖励中的带宽利用率分母
    float congestion_level;        // 0.0~1.0: 拥塞概率, RL 状态特征
    bool in_probe_rtt;             // 是否在探测阶段, RL 应冻结决策
};

struct RLDecision {
    uint32_t target_bitrate_bps;   // <= pacing_rate_bps * 0.95 (留 5% 余量给 FEC/NACK)
    SVCLayerConfig layers;
    bool request_keyframe;
    float priority_weight;         // 传递给 CC: 当前流优先级, 影响 CC 抢占行为
};

# 故障注入场景示例
apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: rl-resilience-test-weekly
spec:
  action: delay
  mode: one
  selector:
    namespaces: [media-server]
    labelSelectors:
      app: media-server
  delay:
    latency: "200ms"
    correlation: "25"
    jitter: "50ms"
  duration: "300s"
  scheduler:
    cron: "@weekly"
---
# 并发注入: 丢包 + 延迟 + 带宽限制组合
# 验证指标: 
# 1. Shield Layer 触发率 < 0.1% (策略应主动规避而非依赖熔断)
# 2. 会话无崩溃、无死锁、内存泄漏
# 3. 恢复期 (故障结束后 60s) QoE 自动回升至故障前水平

┌─────────────┐     加密梯度上传      ┌─────────────┐
│  Client A   │ ──────────────────► │             │
│ (企业私有化部署)  │  (Paillier / CKKS)    │  Parameter  │
└─────────────┘                     │   Server    │
       ▲                            │  (聚合/更新) │
       │ 全局模型下发                 │             │
┌─────────────┐                     └──────┬──────┘
│  Client B   │ ────────────────────────────┘
│ (公有云租户)  │
└─────────────┘