VBAF

5.0.0

VBAF.Enterprise.DataFlowOptimizer.ps1

 #Requires -Version 5.1
<#
.SYNOPSIS
    Pillar 10 - Database & Data Flow Optimization
.DESCRIPTION
    Trains a DQN agent to monitor and optimize data pipeline conditions.
    The agent observes real data flow metrics and learns when to:
      - Throttle : slow down ingestion to protect downstream (action 0)
      - Prioritize: elevate critical data streams (action 1)
      - Cache : buffer hot data to reduce query load (action 2)
      - Reroute : redirect flow away from bottleneck (action 3)
.NOTES
    Part of VBAF - Phase 10 Enterprise Automation Engine
    Pillar 10: Database & Data Flow Optimization
    PS 5.1 compatible
    Real data: SQL queries, CSV streams, pipeline volumes
#>

# ============================================================
# PILLAR 10 - DATABASE & DATA FLOW OPTIMIZATION
# ============================================================

class DataFlowEnvironment {

    # State: 4 normalised data pipeline health dimensions (0.0 - 1.0)
    [double] $SeverityNorm    # CurrentSeverity/3.0 - direct action signal (state[0])
    [double] $PipelineLoad    # 0=idle 1=saturated (queue depth)
    [double] $QueryLatency    # 0=fast(<10ms) 1=slow(>5000ms)
    [double] $ErrorRate       # 0=clean 1=high failure rate

    [int]    $CorrectActions
    [int]    $MissedBottlenecks
    [int]    $Steps
    [double] $TotalReward
    [int]    $EpisodeCount

    # Confusion matrix
    [int]    $TruePositives
    [int]    $FalsePositives
    [int]    $TrueNegatives
    [int]    $FalseNegatives

    [int]    $CurrentSeverity  # raw 0-3 (maps directly to optimal action)

    # Required by VBAF framework
    [int]    $StateSize  = 4
    [int]    $ActionSize = 4

    # Step() stores result here — avoids PSCustomObject type corruption (PS 5.1)
    [double] $LastReward = 0.0
    [bool]   $LastDone   = $false

    DataFlowEnvironment() {
        $this.Reset() | Out-Null
    }

    # CRITICAL PS 5.1: build strictly typed [double[]] element by element
    # state[0] = SeverityNorm — direct action signal, proven pattern from Pillars 8-9
    [double[]] GetState() {
        [double[]] $s = @(0.0, 0.0, 0.0, 0.0)
        $s[0] = $this.SeverityNorm
        $s[1] = $this.PipelineLoad
        $s[2] = $this.QueryLatency
        $s[3] = $this.ErrorRate
        return $s
    }

    [double[]] Reset() {
        $this.Steps              = 0
        $this.TotalReward        = 0.0
        $this.CorrectActions     = 0
        $this.MissedBottlenecks  = 0
        $this.TruePositives      = 0
        $this.FalsePositives     = 0
        $this.TrueNegatives      = 0
        $this.FalseNegatives     = 0
        $this.LastDone           = $false   # CRITICAL: must reset here
        $this.EpisodeCount++
        $this._SampleCondition()
        [double[]] $initState = $this.GetState()
        return $initState
    }

    [void] _SampleCondition() {
        # Balanced training distribution — no lazy fixed-action exploits
        # 25% light (0), 30% moderate (1), 25% heavy (2), 20% critical (3)
        $roll = Get-Random -Minimum 1 -Maximum 100
        if      ($roll -le 25) { $this.CurrentSeverity = 0 }
        elseif  ($roll -le 55) { $this.CurrentSeverity = 1 }
        elseif  ($roll -le 80) { $this.CurrentSeverity = 2 }
        else                   { $this.CurrentSeverity = 3 }

        # SeverityNorm = direct action signal in state[0]
        [double[]] $snArr = @(0.0)
        $snArr[0]  = $this.CurrentSeverity
        $snArr[0] /= 3.0
        $this.SeverityNorm = $snArr[0]

        # Generate pipeline metrics consistent with severity
        switch ($this.CurrentSeverity) {
            0 {
                # Light load: healthy pipeline, fast queries, clean
                $this.PipelineLoad  = [double](Get-Random -Minimum 5  -Maximum 30)  / 100.0
                $this.QueryLatency  = [double](Get-Random -Minimum 1  -Maximum 20)  / 5000.0
                $this.ErrorRate     = 0.0
            }
            1 {
                # Moderate: elevated queue, slightly slow queries
                $this.PipelineLoad  = [double](Get-Random -Minimum 30 -Maximum 60)  / 100.0
                $this.QueryLatency  = [double](Get-Random -Minimum 50 -Maximum 300) / 5000.0
                $this.ErrorRate     = [double](Get-Random -Minimum 0  -Maximum 5)   / 100.0
            }
            2 {
                # Heavy: high queue depth, slow queries, some errors
                $this.PipelineLoad  = [double](Get-Random -Minimum 60 -Maximum 85)  / 100.0
                $this.QueryLatency  = [double](Get-Random -Minimum 300 -Maximum 2000) / 5000.0
                $this.ErrorRate     = [double](Get-Random -Minimum 5  -Maximum 20)  / 100.0
            }
            3 {
                # Critical: saturated, timeout-level latency, high errors
                $this.PipelineLoad  = [double](Get-Random -Minimum 85  -Maximum 100) / 100.0
                $this.QueryLatency  = [double](Get-Random -Minimum 2000 -Maximum 5000) / 5000.0
                $this.ErrorRate     = [double](Get-Random -Minimum 20  -Maximum 100) / 100.0
            }
        }
    }

    [int] _OptimalAction() {
        # Pure severity mapping — clean 4-class signal for DQN
        # 0=Throttle 1=Prioritize 2=Cache 3=Reroute
        return $this.CurrentSeverity
    }

    [void] Step([int]$action) {
        $this.Steps++
        $optimal = $this._OptimalAction()

        # Symmetric distance-based reward (proven in Pillars 8-9)
        # +2 correct, -1 dist=1, -2 dist=2, -3 dist=3
        [int] $dist = $action - $optimal
        if ($dist -lt 0) { $dist = -$dist }  # PS 5.1 safe abs

        if    ($dist -eq 0) { $this.LastReward =  2.0; $this.CorrectActions++ }
        elseif($dist -eq 1) { $this.LastReward = -1.0 }
        elseif($dist -eq 2) { $this.LastReward = -2.0 }
        else                { $this.LastReward = -3.0 }

        if ($this.CurrentSeverity -ge 2 -and $action -lt 2) { $this.MissedBottlenecks++ }

        $isCritical  = ($this.CurrentSeverity -ge 2)
        $agentActs   = ($action -ge 2)
        if ($isCritical  -and $agentActs)  { $this.TruePositives++  }
        if (!$isCritical -and $agentActs)  { $this.FalsePositives++ }
        if (!$isCritical -and !$agentActs) { $this.TrueNegatives++  }
        if ($isCritical  -and !$agentActs) { $this.FalseNegatives++ }

        $this.TotalReward += $this.LastReward
        $this._SampleCondition()
        $this.LastDone = ($this.Steps -ge 200)
    }
}

# ------------------------------------
# Real Windows Data Flow probe
# ------------------------------------
function Get-VBAFDataFlowSnapshot {
    [CmdletBinding()]
    param()

    Write-Host ""
    Write-Host " Probing live data flow conditions..." -ForegroundColor Gray

    try {
        # CSV pipeline volume — count files and estimate throughput
        $tempPath = $env:TEMP
        $csvFiles = Get-ChildItem -Path $tempPath -Filter "*.csv" -ErrorAction SilentlyContinue
        Write-Host (" CSV files in TEMP : {0}" -f $csvFiles.Count) -ForegroundColor White

        # WMI - disk I/O as proxy for data pipeline load
        $diskStats = Get-WmiObject -Class Win32_PerfRawData_PerfDisk_LogicalDisk `
            -ErrorAction Stop | Where-Object { $_.Name -eq "_Total" }
        if ($diskStats) {
            Write-Host (" Disk read ops : {0}" -f $diskStats.DiskReadsPerSec)  -ForegroundColor DarkCyan
            Write-Host (" Disk write ops : {0}" -f $diskStats.DiskWritesPerSec) -ForegroundColor DarkCyan
        }

        # SQL Server check (if present)
        $sqlService = Get-Service -Name "MSSQLSERVER" -ErrorAction SilentlyContinue
        if ($sqlService) {
            $sqlStatus = $sqlService.Status
            $sqlColour = if ($sqlStatus -eq "Running") { "Green" } else { "Yellow" }
            Write-Host (" SQL Server status : {0}" -f $sqlStatus) -ForegroundColor $sqlColour
        } else {
            Write-Host " SQL Server : not installed (simulation mode)" -ForegroundColor Gray
        }

    } catch {
        Write-Host " [WARNING] Data flow probe incomplete: $($_.Exception.Message)" -ForegroundColor Yellow
        Write-Host " [INFO] Training will use simulated pipeline conditions."    -ForegroundColor Gray
    }
}

# ============================================================
# MAIN TRAINING FUNCTION
# ============================================================
function Invoke-VBAFDataFlowOptimizerTraining {
    param(
        [int]    $Episodes    = 100,
        [int]    $PrintEvery  = 10,
        [switch] $FastMode,
        [switch] $SimMode,
        [switch] $SkipRealData
    )

    Write-Host ""
    Write-Host "🗄️ VBAF Enterprise - Pillar 10: Database & Data Flow Optimization" -ForegroundColor Cyan
    Write-Host " Training DQN agent on Data Flow Optimizer..."                    -ForegroundColor Cyan
    Write-Host " Actions: 0=Throttle 1=Prioritize 2=Cache 3=Reroute"          -ForegroundColor Yellow
    Write-Host " State : SeverityNorm | PipelineLoad | QueryLatency | ErrorRate" -ForegroundColor Yellow
    Write-Host " Reward : +2 correct -1 dist=1 -2 dist=2 -3 dist=3"           -ForegroundColor Yellow
    Write-Host ""

    if (-not $SkipRealData) {
        Get-VBAFDataFlowSnapshot
    }

    $dfEnv = [DataFlowEnvironment]::new()

    # Phase 1: Baseline — inline random loop
    Write-Host " Phase 1: Baseline (random agent - 10 episodes)..." -ForegroundColor Gray
    $baseRewards = @()
    for ($b = 1; $b -le 10; $b++) {
        $dfEnv.Reset() | Out-Null
        $bReward = 0.0
        while (-not $dfEnv.LastDone) {
            $rAction  = Get-Random -Minimum 0 -Maximum 4
            $dfEnv.Step($rAction)
            $bReward += $dfEnv.LastReward
        }
        $baseRewards += $bReward
    }
    [double[]] $bAvgArr = @(0.0)
    $bAvgArr[0] = ($baseRewards | Measure-Object -Average).Average
    Write-Host (" Baseline avg reward: {0:F2}" -f $bAvgArr[0]) -ForegroundColor Gray

    if ($FastMode) { $Episodes = [Math]::Min($Episodes, 30) }
    Write-Host ""
    Write-Host " Phase 2: Training DQN agent ($Episodes episodes)..." -ForegroundColor Gray

    # DQN setup - 4 state, 4 actions
    $config              = [DQNConfig]::new()
    $config.StateSize    = 4
    $config.ActionSize   = 4
    $config.EpsilonDecay = 0.9995
    $config.EpsilonMin   = 0.05
    [int[]] $arch        = @(4, 24, 24, 4)
    $mainNetwork         = [NeuralNetwork]::new($arch, $config.LearningRate)
    $targetNetwork       = [NeuralNetwork]::new($arch, $config.LearningRate)
    $memory              = [ExperienceReplay]::new($config.MemorySize)
    $agent               = [DQNAgent]::new($config, $mainNetwork, $targetNetwork, $memory)

    $results = [System.Collections.Generic.List[object]]::new()

    for ($ep = 1; $ep -le $Episodes; $ep++) {

        # CRITICAL PS 5.1: $state must be strictly typed [double[]] for DQN
        [double[]] $state = @(0.0, 0.0, 0.0, 0.0)

        if ($SimMode) {
            # SimMode: inject balanced pipeline severity distribution directly
            $roll = Get-Random -Minimum 1 -Maximum 100
            if      ($roll -le 25) { $dfEnv.CurrentSeverity = 0 }
            elseif  ($roll -le 55) { $dfEnv.CurrentSeverity = 1 }
            elseif  ($roll -le 80) { $dfEnv.CurrentSeverity = 2 }
            else                   { $dfEnv.CurrentSeverity = 3 }

            [double[]] $snArr = @(0.0)
            $snArr[0]  = $dfEnv.CurrentSeverity
            $snArr[0] /= 3.0
            $dfEnv.SeverityNorm = $snArr[0]

            switch ($dfEnv.CurrentSeverity) {
                0 {
                    $dfEnv.PipelineLoad = [double](Get-Random -Minimum 5  -Maximum 30)  / 100.0
                    $dfEnv.QueryLatency = [double](Get-Random -Minimum 1  -Maximum 20)  / 5000.0
                    $dfEnv.ErrorRate    = 0.0
                }
                1 {
                    $dfEnv.PipelineLoad = [double](Get-Random -Minimum 30 -Maximum 60)  / 100.0
                    $dfEnv.QueryLatency = [double](Get-Random -Minimum 50 -Maximum 300) / 5000.0
                    $dfEnv.ErrorRate    = [double](Get-Random -Minimum 0  -Maximum 5)   / 100.0
                }
                2 {
                    $dfEnv.PipelineLoad = [double](Get-Random -Minimum 60 -Maximum 85)  / 100.0
                    $dfEnv.QueryLatency = [double](Get-Random -Minimum 300 -Maximum 2000) / 5000.0
                    $dfEnv.ErrorRate    = [double](Get-Random -Minimum 5  -Maximum 20)  / 100.0
                }
                3 {
                    $dfEnv.PipelineLoad = [double](Get-Random -Minimum 85  -Maximum 100) / 100.0
                    $dfEnv.QueryLatency = [double](Get-Random -Minimum 2000 -Maximum 5000) / 5000.0
                    $dfEnv.ErrorRate    = [double](Get-Random -Minimum 20  -Maximum 100) / 100.0
                }
            }
            $dfEnv.CorrectActions    = 0
            $dfEnv.MissedBottlenecks = 0
            $dfEnv.Steps             = 0
            $dfEnv.TotalReward       = 0.0
            $dfEnv.LastDone          = $false
            $dfEnv.EpisodeCount++
            $state = $dfEnv.GetState()
        } else {
            $state = $dfEnv.Reset()
        }

        $done             = $false
        $epReward         = 0.0
        $throttleCount    = 0
        $prioritizeCount  = 0
        $cacheCount       = 0
        $rerouteCount     = 0
        [int] $stepCount  = 0

        while (-not $done) {
            $action = $agent.Act($state)
            $dfEnv.Step($action)
            # Read directly from env — NO PSCustomObject round-trip
            [double[]] $nextState = $dfEnv.GetState()
            [double]   $reward    = $dfEnv.LastReward
            [bool]     $isDone    = $dfEnv.LastDone
            $agent.Remember($state, $action, $reward, $nextState, $isDone)
            $stepCount++
            if ($stepCount % 4 -eq 0) { $agent.Replay() }
            $state     = $nextState
            $done      = $isDone
            $epReward += $reward
            switch ($action) {
                0 { $throttleCount++   }
                1 { $prioritizeCount++ }
                2 { $cacheCount++      }
                3 { $rerouteCount++    }
            }
        }

        $agent.EndEpisode($epReward)
        $results.Add(@{
            Episode    = $ep
            Reward     = $epReward
            Throttle   = $throttleCount
            Prioritize = $prioritizeCount
            Cache      = $cacheCount
            Reroute    = $rerouteCount
            Epsilon    = $agent.Epsilon
        })

        if ($ep % $PrintEvery -eq 0) {
            $lastN  = $results | Select-Object -Last $PrintEvery
            $avgSum = 0.0
            foreach ($r2 in $lastN) { $avgSum += $r2.Reward }
            [double[]] $avgArr = @(0.0)
            $avgArr[0]  = $avgSum
            $avgArr[0] /= $lastN.Count
            $avg = [Math]::Round($avgArr[0], 2)
            Write-Host (" Ep {0,4}/{1} AvgReward: {2,7} Eps: {3:F3} Thr:{4} Pri:{5} Cac:{6} Rer:{7}" -f `
                $ep, $Episodes, $avg, $agent.Epsilon, $throttleCount, $prioritizeCount, $cacheCount, $rerouteCount) -ForegroundColor White
        }
    }

    # Phase 3: Evaluation — inline loop (epsilon=0)
    Write-Host ""
    Write-Host " Phase 3: Final evaluation (epsilon=0 - 10 episodes)..." -ForegroundColor Gray
    $agent.Epsilon = 0.0
    $trainedRewards = @()
    for ($t = 1; $t -le 10; $t++) {
        [double[]] $evalState = $dfEnv.Reset()
        $tReward = 0.0
        while (-not $dfEnv.LastDone) {
            $tAction = $agent.Act($evalState)
            $dfEnv.Step($tAction)
            [double[]] $evalState = $dfEnv.GetState()
            $tReward += $dfEnv.LastReward
        }
        $trainedRewards += $tReward
    }
    [double[]] $tAvgArr = @(0.0)
    $tAvgArr[0] = ($trainedRewards | Measure-Object -Average).Average
    Write-Host (" Trained avg reward: {0:F2}" -f $tAvgArr[0]) -ForegroundColor Green

    [double[]] $impArr = @(0.0)
    if ($bAvgArr[0] -ne 0) {
        $impArr[0]  = $tAvgArr[0] - $bAvgArr[0]
        $impArr[0] /= [Math]::Abs($bAvgArr[0])
        $impArr[0] *= 100.0
    }
    $bAvg        = [Math]::Round($bAvgArr[0], 2)
    $tAvg        = [Math]::Round($tAvgArr[0], 2)
    $improvement = [Math]::Round($impArr[0], 1)

    # Precision / Recall
    [double[]] $precArr = @(0.0)
    [double[]] $recArr  = @(0.0)
    $denomP = $dfEnv.TruePositives + $dfEnv.FalsePositives
    $denomR = $dfEnv.TruePositives + $dfEnv.FalseNegatives
    if ($denomP -gt 0) { $precArr[0] = $dfEnv.TruePositives; $precArr[0] /= $denomP }
    if ($denomR -gt 0) { $recArr[0]  = $dfEnv.TruePositives; $recArr[0]  /= $denomR }
    $precPct = [Math]::Round($precArr[0] * 100, 1)
    $recPct  = [Math]::Round($recArr[0]  * 100, 1)

    Write-Host ""
    Write-Host "╔══════════════════════════════════════════════════╗" -ForegroundColor Cyan
    Write-Host "║ Pillar 10: Data Flow Optimizer - Results ║" -ForegroundColor Cyan
    Write-Host "╠══════════════════════════════════════════════════╣" -ForegroundColor Cyan
    Write-Host ("║ Baseline (random) avg reward : {0,8} ║" -f $bAvg)        -ForegroundColor Gray
    Write-Host ("║ Trained (DQN) avg reward : {0,8} ║" -f $tAvg)        -ForegroundColor Green
    Write-Host ("║ Improvement : {0,7}% ║" -f $improvement) -ForegroundColor Yellow
    Write-Host "╠══════════════════════════════════════════════════╣" -ForegroundColor Cyan
    Write-Host ("║ Precision (Cache+Reroute corr): {0,7}% ║" -f $precPct)     -ForegroundColor Cyan
    Write-Host ("║ Recall (bottlenecks caught): {0,7}% ║" -f $recPct)      -ForegroundColor Cyan
    Write-Host "╠══════════════════════════════════════════════════╣" -ForegroundColor Cyan
    Write-Host "║ Agent learned to: ║" -ForegroundColor Cyan
    Write-Host "║ Throttle light load conditions ║" -ForegroundColor White
    Write-Host "║ Prioritize moderate pipeline pressure ║" -ForegroundColor White
    Write-Host "║ Cache heavy query load ║" -ForegroundColor White
    Write-Host "║ Reroute critical bottlenecks immediately ║" -ForegroundColor White
    Write-Host "╚══════════════════════════════════════════════════╝" -ForegroundColor Cyan
    Write-Host ""

    return @{ Agent = $agent; Results = $results; Baseline = @{ Avg = $bAvg }; Trained = @{ Avg = $tAvg } }
}

# ============================================================
# TEST SUGGESTIONS
# ============================================================
# 1. Run VBAF.LoadAll.ps1 (loads core DQN + all pillars)
#
# 2. QUICK DEMO (simulated pipeline conditions, no admin needed)
# $r = Invoke-VBAFDataFlowOptimizerTraining -Episodes 100 -PrintEvery 10 -SimMode
#
# 3. FULL TRAINING (real Windows disk/SQL data)
# $r = Invoke-VBAFDataFlowOptimizerTraining -Episodes 100 -PrintEvery 10
#
# 4. SKIP REAL DATA PROBE
# $r = Invoke-VBAFDataFlowOptimizerTraining -Episodes 100 -PrintEvery 10 -SkipRealData
#
# 5. INSPECT AGENT DECISIONS
# $env = [DataFlowEnvironment]::new()
# $state = $env.Reset()
# Write-Host "PipelineLoad: $($env.PipelineLoad) QueryLatency: $($env.QueryLatency)"
# $action = $r.Agent.Act($state)
# $labels = @("Throttle","Prioritize","Cache","Reroute")
# Write-Host "Agent decision: $($labels[$action])"
#
# 6. VIEW CONFUSION MATRIX
# Write-Host "True Positives : $($env.TruePositives)"
# Write-Host "False Positives: $($env.FalsePositives)"
# Write-Host "True Negatives : $($env.TrueNegatives)"
# Write-Host "False Negatives: $($env.FalseNegatives)"
# ============================================================
Write-Host "📦 VBAF.Enterprise.DataFlowOptimizer.ps1 loaded [v3.0.0 🗄️]"  -ForegroundColor Green
Write-Host " Pillar 10: Database & Data Flow Optimization"                 -ForegroundColor Cyan
Write-Host " Function : Invoke-VBAFDataFlowOptimizerTraining"             -ForegroundColor Cyan
Write-Host ""
Write-Host " Quick start:" -ForegroundColor Yellow
Write-Host ' $r = Invoke-VBAFDataFlowOptimizerTraining -Episodes 100 -PrintEvery 10 -SimMode' -ForegroundColor White
Write-Host ""